The way polling triggers usually work is as follows:

On Enable: Store the last timestamp or most recent item id using the context store property.

Run: This method runs every 5 minutes, fetches the endpoint between a certain timestamp or traverses until it finds the last item id, and returns the new items as an array.

Testing: You cannot test it with Test Flow, as it uses static sample data provided in the piece. To test the trigger, publish the flow, perform the event, and wait for the run to be invoked (every 5 minutes) on the third party. Then check the flow runs from the main dashboard.

Examples:

​
Polling library

There multiple strategy to implement polling triggers, and we have created a library to help you with that.

​
Strategies

Timebased:

This strategy fetches new items using a timestamp. You need to implement the items method, which should return the most recent items. The library will detect new items based on the timestamp.

The polling object’s generic type consists of the props value and the object type.

const polling: Polling<{ authentication: OAuth2PropertyValue, object: string }> = {
  strategy: DedupeStrategy.TIMEBASED,
  items: async ({ propsValue, lastFetchEpochMS }) => {
    // Todo implement the logic to fetch the items
    const items = [ {id: 1, created_date: '2021-01-01T00:00:00Z'}, {id: 2, created_date: '2021-01-01T00:00:00Z'}];
    return items.map((item) => ({
      epochMilliSeconds: dayjs(item.created_date).valueOf(),
      data: item,
    }));
  }
}

Last ID Strategy:

This strategy fetches new items based on the last item ID. To use this strategy, you need to implement the items method, which should return the most recent items. The library will detect new items after the last item ID.

The polling object’s generic type consists of the props value and the object type

const polling: Polling<{ authentication: AuthProps}> = {
    strategy: DedupeStrategy.LAST_ITEM,
    items: async ({ propsValue }) => {
        // Implement the logic to fetch the items
        const items = [{ id: 1 }, { id: 2 }];
        return items.map((item) => ({
            id: item.id,
            data: item,
        }));
    }
}

​
Trigger Implementation

After implementing the polling object, you can use the polling helper to implement the trigger.

export const newTicketInView = createTrigger({
    name: 'new_ticket_in_view',
    displayName: 'New ticket in view',
    description: 'Triggers when a new ticket is created in a view',
    type: TriggerStrategy.POLLING,
    props: {
        authentication: Property.SecretText({
            displayName: 'Authentication',
            description: markdownProperty,
            required: true,
        }),
    },
    sampleData: {},
    onEnable: async (context) => {
        await pollingHelper.onEnable(polling, {
            store: context.store,
            propsValue: context.propsValue,
        })
    },
    onDisable: async (context) => {
        await pollingHelper.onDisable(polling, {
            store: context.store,
            propsValue: context.propsValue,
        })
    },
    run: async (context) => {
        return await pollingHelper.poll(polling, {
            store: context.store,
            propsValue: context.propsValue,
        });
    },
    test: async (context) => {
        return await pollingHelper.test(polling, {
            store: context.store,
            propsValue: context.propsValue,
        });
    }
});
OverviewWebhook Trigger