Create a Trigger

npm run create-trigger

import { createTrigger, Property, TriggerStrategy } from '@activepieces/pieces-framework';
import { pollingAuth } from '../auth';
import Parser from 'rss-parser';

export const newRssItem = createTrigger({
  auth: pollingAuth,
  name: 'new_item_in_feed',
  displayName: 'New Item in Feed',
  description: 'Triggers when a new item is published in an RSS feed',
  
  // Polling trigger type
  type: TriggerStrategy.POLLING,
  
  props: {
    feedUrl: Property.ShortText({
      displayName: 'Feed URL',
      description: 'The URL of the RSS feed',
      required: true,
    }),
  },
  
  // Sample data for testing
  sampleData: {
    title: 'Sample Article',
    link: 'https://example.com/article',
    pubDate: '2024-01-15T10:00:00Z',
    content: 'Article content...',
  },
  
  // Called when trigger is enabled
  async onEnable(context) {
    // Optional: Store initial state
    const parser = new Parser();
    const feed = await parser.parseURL(context.propsValue.feedUrl);
    
    if (feed.items.length > 0) {
      // Store the latest item's date to avoid duplicates
      await context.store.put('lastPubDate', feed.items[0].pubDate);
    }
  },
  
  // Called when trigger is disabled
  async onDisable(context) {
    // Cleanup if needed
    await context.store.delete('lastPubDate');
  },
  
  // Called periodically to check for new items
  async run(context) {
    const parser = new Parser();
    const feed = await parser.parseURL(context.propsValue.feedUrl);
    
    // Get last processed date
    const lastPubDate = await context.store.get<string>('lastPubDate');
    const lastDate = lastPubDate ? new Date(lastPubDate) : null;
    
    // Filter new items
    const newItems = feed.items.filter((item) => {
      if (!lastDate) return true;
      const itemDate = new Date(item.pubDate || '');
      return itemDate > lastDate;
    });
    
    // Update last processed date
    if (newItems.length > 0) {
      await context.store.put('lastPubDate', newItems[0].pubDate);
    }
    
    // Return new items (they'll trigger flow executions)
    return newItems;
  },
});

import { createTrigger, Property, TriggerStrategy } from '@activepieces/pieces-framework';
import { githubAuth } from '../auth';
import { DedupeStrategy, HttpMethod, httpClient } from '@activepieces/pieces-common';

export const newIssue = createTrigger({
  auth: githubAuth,
  name: 'new_issue',
  displayName: 'New Issue',
  description: 'Triggers when a new issue is created',
  
  // Webhook trigger type
  type: TriggerStrategy.WEBHOOK,
  
  props: {
    repository: Property.ShortText({
      displayName: 'Repository',
      description: 'Repository name (owner/repo)',
      required: true,
    }),
  },
  
  sampleData: {
    action: 'opened',
    issue: {
      id: 1,
      number: 42,
      title: 'Sample Issue',
      body: 'Issue description',
      user: {
        login: 'username',
      },
      created_at: '2024-01-15T10:00:00Z',
    },
  },
  
  // Register webhook when enabled
  async onEnable(context) {
    const [owner, repo] = context.propsValue.repository.split('/');
    
    // Register webhook with GitHub
    const response = await httpClient.sendRequest({
      method: HttpMethod.POST,
      url: `https://api.github.com/repos/${owner}/${repo}/hooks`,
      headers: {
        'Authorization': `Bearer ${context.auth.access_token}`,
        'Content-Type': 'application/json',
      },
      body: {
        name: 'web',
        active: true,
        events: ['issues'],
        config: {
          url: context.webhookUrl, // Platform provides this
          content_type: 'json',
          secret: context.webhookSecret, // For verification
        },
      },
    });
    
    // Store webhook ID for cleanup
    await context.store.put('webhookId', response.body.id);
  },
  
  // Unregister webhook when disabled
  async onDisable(context) {
    const webhookId = await context.store.get<number>('webhookId');
    if (!webhookId) return;
    
    const [owner, repo] = context.propsValue.repository.split('/');
    
    await httpClient.sendRequest({
      method: HttpMethod.DELETE,
      url: `https://api.github.com/repos/${owner}/${repo}/hooks/${webhookId}`,
      headers: {
        'Authorization': `Bearer ${context.auth.access_token}`,
      },
    });
    
    await context.store.delete('webhookId');
  },
  
  // Process incoming webhook data
  async run(context) {
    const payload = context.payload.body;
    
    // Filter for new issues only
    if (payload.action !== 'opened') {
      return [];
    }
    
    // Return the issue data
    return [payload];
  },
});

interface TriggerContext {
  auth: OAuth2PropertyValue | string | CustomAuthValue;
  propsValue: Record<string, any>;
  
  // Webhook-specific
  webhookUrl?: string;      // URL to register with service
  webhookSecret?: string;   // Secret for verification
  payload?: {               // Incoming webhook data
    body: any;
    headers: Record<string, string>;
    rawBody: string;
  };
  
  // App webhook specific
  app?: {
    createListeners(config: {
      events: string[];
      identifierValue: string;
    }): void;
  };
  
  // Storage
  store: {
    get<T>(key: string): Promise<T | null>;
    put<T>(key: string, value: T): Promise<void>;
    delete(key: string): Promise<void>;
  };
}

import { DEDUPE_KEY_PROPERTY } from '@activepieces/pieces-framework';

async run(context) {
  const newItems = await fetchNewItems();
  
  // Add dedupe key to each item
  return newItems.map((item) => ({
    ...item,
    [DEDUPE_KEY_PROPERTY]: item.id, // Use unique identifier
  }));
}