@agnocon/piece-bitly 0.1.7

package/src/lib/common/client.ts

@@ -0,0 +1,122 @@
+import {
+  httpClient,
+  HttpMethod,
+  HttpRequest,
+  HttpMessageBody,
+  QueryParams,
+} from '@agnocon/pieces-common';
+
+export type BitlyAuthProps = {
+  accessToken: string;
+};
+
+export type BitlyApiCallParams = {
+  method: HttpMethod;
+  resourceUri: string;
+  query?: Record<string, string | number | string[] | undefined>;
+  body?: any;
+  auth: BitlyAuthProps;
+};
+
+export async function bitlyApiCall<T extends HttpMessageBody>({
+  method,
+  resourceUri,
+  query,
+  body,
+  auth,
+}: BitlyApiCallParams): Promise<T> {
+  const { accessToken } = auth;
+
+  if (!accessToken) {
+    throw new Error('Bitly Access Token is required for authentication');
+  }
+
+  const queryParams: QueryParams = {};
+
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== null && value !== undefined) {
+        queryParams[key] = String(value);
+      }
+    }
+  }
+
+  const baseUrl = 'https://api-ssl.bitly.com/v4';
+
+  const request: HttpRequest = {
+    method,
+    url: `${baseUrl}${resourceUri}`,
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      'Content-Type': 'application/json',
+    },
+    queryParams,
+    body,
+  };
+
+  try {
+    const response = await httpClient.sendRequest<T>(request);
+    return response.body;
+  } catch (error: any) {
+    const statusCode = error.response?.status;
+    const errorData = error.response?.data;
+    const errorMessage = errorData?.description || errorData?.message || 'Unknown error occurred';
+
+    switch (statusCode) {
+      case 400:
+        throw new Error(
+          `Bad Request: ${errorMessage}. Please check your input parameters.`
+        );
+
+      case 401:
+        throw new Error(
+          'Authentication Failed: Invalid Access Token. Please verify your Bitly credentials in the connection settings.'
+        );
+
+      case 402:
+        throw new Error(
+            `Payment Required: ${errorMessage}. Your account has been suspended or you have reached a usage limit.`
+        );
+
+      case 403:
+        throw new Error(
+          `Access Forbidden: ${errorMessage}. You do not have permission to access this resource.`
+        );
+
+      case 404:
+        throw new Error(
+          `Resource Not Found: ${errorMessage}. The requested resource does not exist.`
+        );
+
+      case 417:
+          throw new Error(
+              `Expectation Failed: ${errorMessage}. You must agree to the latest terms of service.`
+          );
+
+      case 422:
+        throw new Error(
+            `Unprocessable Entity: ${errorMessage}. The request was well-formed but was unable to be followed due to semantic errors.`
+        );
+
+      case 429:
+        throw new Error(
+          `Rate Limit Exceeded: ${errorMessage}. Too many requests. Please wait before trying again.`
+        );
+
+      case 500:
+        throw new Error(
+          'Internal Server Error: Bitly is experiencing technical difficulties. Please try again later.'
+        );
+        
+      case 503:
+        throw new Error(
+          'Service Unavailable: Bitly service is temporarily unavailable. Please try again in a few minutes.'
+        );
+
+      default:
+        throw new Error(
+          `Bitly API Error (${statusCode || 'Unknown'}): ${errorMessage}`
+        );
+    }
+  }
+}

package/src/lib/common/props.ts

@@ -0,0 +1,123 @@
+import { Property } from '@agnocon/pieces-framework';
+import { HttpMethod } from '@agnocon/pieces-common';
+import { bitlyApiCall } from './client';
+import { BitlyAuthProps } from './client';
+import { bitlyAuth } from './auth';
+
+interface BitlyGroup {
+  guid: string;
+  name: string;
+  bsds: Array<{ domain: string }>;
+}
+
+interface Bitlink {
+    id: string;
+    title: string;
+}
+
+const getBitlyGroups = async (auth: BitlyAuthProps): Promise<BitlyGroup[]> => {
+    const response = await bitlyApiCall<{ groups: BitlyGroup[] }>({
+        auth,
+        method: HttpMethod.GET,
+        resourceUri: '/groups',
+    });
+    return response.groups || [];
+};
+
+export const groupGuid = Property.Dropdown({
+  displayName: 'Group',
+  description: 'The group where the item will be managed.',
+  required: true,
+  refreshers: [],
+  auth:bitlyAuth ,
+  options: async ({ auth }) => {
+    if (!auth) {
+      return { disabled: true, options: [], placeholder: 'Please connect your Bitly account first.' };
+    }
+    const { accessToken } = auth.props;
+    if (!accessToken) {
+      return { disabled: true, options: [], placeholder: 'Please connect your Bitly account first.' };
+    }
+    try {
+      const groups = await getBitlyGroups({ accessToken });
+      if (groups.length === 0) {
+        return { disabled: true, options: [], placeholder: 'No groups found in your account.' };
+      }
+      return {
+        disabled: false,
+        options: groups.map((group) => ({
+          label: group.name,
+          value: group.guid,
+        })),
+      };
+    } catch (e) {
+      return { disabled: true, options: [], placeholder: `Error fetching groups: ${(e as Error).message}` };
+    }
+  },
+});
+
+export const domain = Property.Dropdown({
+  auth: bitlyAuth,
+    displayName: 'Domain',
+    description: 'Domain to use for the Bitlink.',
+    required: false,
+    refreshers: ['group_guid'],
+    options: async ({ auth, group_guid }) => {
+        if (!auth) {
+          return { disabled: true, options: [], placeholder: 'Please connect your Bitly account first.' };
+        }
+        const { accessToken } = auth.props;
+        if (!accessToken || !group_guid) {
+            return { disabled: true, options: [], placeholder: 'Please select a group first.' };
+        }
+        try {
+            const groups = await getBitlyGroups({ accessToken });
+            const selectedGroup = groups.find(g => g.guid === group_guid);
+            const customDomains = selectedGroup?.bsds?.map(bsd => bsd.domain) || [];
+            const allDomains = ['bit.ly', ...customDomains];
+            return {
+                disabled: false,
+                options: allDomains.map(d => ({
+                    label: d,
+                    value: d,
+                })),
+            };
+        } catch (e) {
+            return { disabled: true, options: [], placeholder: `Error fetching domains: ${(e as Error).message}` };
+        }
+    },
+});
+
+export const bitlinkDropdown = Property.Dropdown({
+    displayName: 'Bitlink',
+    description: 'Select the Bitlink to modify.',
+    required: true,
+    refreshers: ['group_guid'],
+    auth: bitlyAuth,
+    options: async ({ auth, group_guid }) => {
+
+        if (!auth) {
+          return { disabled: true, options: [], placeholder: 'Please connect your Bitly account first.' };
+        }
+        const { accessToken } = auth.props;
+        if (!accessToken) return { disabled: true, options: [], placeholder: 'Please connect your Bitly account first.' };
+        if (!group_guid) return { disabled: true, options: [], placeholder: 'Please select a group first.' };
+        
+        try {
+            const response = await bitlyApiCall<{ links: Bitlink[] }>({
+                auth: { accessToken },
+                method: HttpMethod.GET,
+                resourceUri: `/groups/${group_guid as string}/bitlinks`,
+            });
+            return {
+                disabled: false,
+                options: response.links.map(link => ({
+                    label: `${link.title || 'No Title'} (${link.id})`,
+                    value: link.id
+                }))
+            };
+        } catch (e) {
+            return { disabled: true, options: [], placeholder: `Error fetching Bitlinks: ${(e as Error).message}` };
+        }
+    }
+});

package/src/lib/triggers/new-bitlink-created.ts

@@ -0,0 +1,361 @@
+import { createTrigger, TriggerStrategy, Property } from '@agnocon/pieces-framework';
+import { HttpMethod } from '@agnocon/pieces-common';
+import { bitlyAuth } from '../common/auth';
+import { bitlyApiCall } from '../common/client';
+import { groupGuid } from '../common/props';
+
+const LAST_BITLINK_IDS_KEY = 'bitly-last-bitlink-ids';
+
+export const newBitlinkCreatedTrigger = createTrigger({
+  auth: bitlyAuth,
+  name: 'new_bitlink_created',
+  displayName: 'New Bitlink Created',
+  description: 'Fires when a new Bitlink is created.',
+  aiMetadata: {
+    description: 'Fires when a new Bitlink appears in the selected group, detected by polling. Represents a newly created short link, optionally narrowed to those whose title or tags match a filter and optionally including archived links.',
+  },
+  type: TriggerStrategy.POLLING,
+  props: {
+    pollingInterval: Property.StaticDropdown({
+      displayName: 'Polling Interval',
+      description: 'How frequently to check for new Bitlinks.',
+      required: false,
+      defaultValue: '5',
+      options: {
+        disabled: false,
+        options: [
+          { label: 'Every 1 minute', value: '1' },
+          { label: 'Every 5 minutes', value: '5' },
+          { label: 'Every 15 minutes', value: '15' },
+          { label: 'Every 30 minutes', value: '30' },
+          { label: 'Every hour', value: '60' },
+        ],
+      },
+    }),
+    
+    group_guid: groupGuid,
+    
+    titleFilter: Property.ShortText({
+      displayName: 'Title Filter (Optional)',
+      description: 'Only trigger for Bitlinks containing this text in their title.',
+      required: false,
+    }),
+    
+    tagFilter: Property.ShortText({
+      displayName: 'Tag Filter (Optional)',
+      description: 'Only trigger for Bitlinks containing this tag.',
+      required: false,
+    }),
+    
+    includeArchived: Property.Checkbox({
+      displayName: 'Include Archived Bitlinks',
+      description: 'Include archived Bitlinks in monitoring.',
+      required: false,
+      defaultValue: false,
+    }),
+  },
+
+  async onEnable(context) {
+    const { group_guid } = context.propsValue;
+    const { accessToken } = context.auth.props;
+
+    try {
+      const response = await bitlyApiCall<{ links: BitlyLink[] }>({
+        auth: { accessToken },
+        method: HttpMethod.GET,
+        resourceUri: `/groups/${group_guid}/bitlinks`,
+        query: {
+          size: 50,
+          archived: context.propsValue.includeArchived ? 'both' : 'off',
+        },
+      });
+
+      const linkIds = response.links.map((link) => link.id);
+      await context.store.put<string[]>(LAST_BITLINK_IDS_KEY, linkIds);
+      
+      console.log(`Bitly New Bitlink trigger initialized with ${linkIds.length} existing links`);
+    } catch (error: any) {
+      if (error.response?.status === 401) {
+        throw new Error(
+          'Authentication failed: Please check your access token. Make sure your token has permission to access Bitlinks.'
+        );
+      }
+      
+      if (error.response?.status === 403) {
+        throw new Error(
+          'Access denied: You do not have permission to list Bitlinks. Please check your Bitly account permissions.'
+        );
+      }
+      
+      throw new Error(
+        `Failed to initialize Bitlink monitoring: ${error.message || 'Unknown error occurred'}. Please check your Bitly connection.`
+      );
+    }
+  },
+
+  async onDisable() {
+    console.log('Bitly New Bitlink trigger disabled and cleaned up');
+  },
+
+  async run(context) {
+    const { group_guid, titleFilter, tagFilter, includeArchived } = context.propsValue;
+    const { accessToken } = context.auth.props;
+    
+    try {
+      const previousLinkIds = await context.store.get<string[]>(LAST_BITLINK_IDS_KEY) || [];
+
+      const response = await bitlyApiCall<{ links: BitlyLink[] }>({
+        auth: { accessToken },
+        method: HttpMethod.GET,
+        resourceUri: `/groups/${group_guid}/bitlinks`,
+        query: {
+          size: 50,
+          archived: includeArchived ? 'both' : 'off',
+        },
+      });
+
+      const allLinks = response.links || [];
+      const currentLinkIds = allLinks.map((l) => l.id);
+
+      await context.store.put<string[]>(LAST_BITLINK_IDS_KEY, currentLinkIds);
+
+      let newLinks = allLinks.filter((link) => !previousLinkIds.includes(link.id));
+
+      if (titleFilter && titleFilter.trim()) {
+        const filterText = titleFilter.trim().toLowerCase();
+        newLinks = newLinks.filter((link) => 
+          link.title && link.title.toLowerCase().includes(filterText)
+        );
+      }
+
+      if (tagFilter && tagFilter.trim()) {
+        const filterTag = tagFilter.trim().toLowerCase();
+        newLinks = newLinks.filter((link) => 
+          link.tags && Array.isArray(link.tags) && 
+          link.tags.some(tag => tag.toLowerCase().includes(filterTag))
+        );
+      }
+
+      const processedLinks = newLinks.map((link) => ({
+        id: link.id,
+        link: link.link,
+        longUrl: link.long_url,
+        title: link.title,
+        tags: link.tags || [],
+        
+        isArchived: link.archived,
+        
+        createdAt: link.created_at,
+        modifiedAt: link.modified_at,
+        
+        customBitlinks: link.custom_bitlinks || [],
+        
+        references: {
+          group: link.references?.group,
+        },
+        
+        rawLinkData: link,
+        
+        triggerInfo: {
+          detectedAt: new Date().toISOString(),
+          source: 'bitly',
+          type: 'new_bitlink',
+        },
+      }));
+
+      return processedLinks;
+    } catch (error: any) {
+      if (error.response?.status === 401) {
+        throw new Error(
+          'Authentication failed: Your access token may have expired. Please check your Bitly authentication.'
+        );
+      }
+      
+      if (error.response?.status === 429) {
+        throw new Error(
+          'Rate limit exceeded: Bitly API rate limit reached. Consider increasing your polling interval.'
+        );
+      }
+      
+      if (error.response?.status === 403) {
+        throw new Error(
+          'Access denied: You do not have permission to list Bitlinks. Please check your account permissions.'
+        );
+      }
+      
+      throw new Error(
+        `Failed to check for new Bitlinks: ${error.message || 'Unknown error occurred'}. The trigger will retry on the next polling interval.`
+      );
+    }
+  },
+
+  async test(context) {
+    const { group_guid, includeArchived } = context.propsValue;
+    const { accessToken } = context.auth.props;
+
+    try {
+      const response = await bitlyApiCall<{ links: BitlyLink[] }>({
+        auth: { accessToken },
+        method: HttpMethod.GET,
+        resourceUri: `/groups/${group_guid}/bitlinks`,
+        query: {
+          size: 1,
+          archived: includeArchived ? 'both' : 'off',
+        },
+      });
+
+      const links = response.links || [];
+      
+      if (links.length > 0) {
+        const testLink = links[0];
+        return [
+          {
+            id: testLink.id,
+            link: testLink.link,
+            longUrl: testLink.long_url,
+            title: testLink.title,
+            tags: testLink.tags || [],
+            isArchived: testLink.archived,
+            createdAt: testLink.created_at,
+            modifiedAt: testLink.modified_at,
+            customBitlinks: testLink.custom_bitlinks || [],
+            references: {
+              group: testLink.references?.group,
+            },
+            rawLinkData: testLink,
+            triggerInfo: {
+              detectedAt: new Date().toISOString(),
+              source: 'bitly',
+              type: 'new_bitlink',
+            },
+          },
+        ];
+      } else {
+        return [
+          {
+            id: 'bit.ly/test123',
+            link: 'https://bit.ly/test123',
+            longUrl: 'https://example.com/very-long-url',
+            title: 'Sample Bitlink',
+            tags: ['sample', 'test'],
+            isArchived: false,
+            createdAt: '2025-01-15T10:00:00+0000',
+            modifiedAt: '2025-01-15T10:00:00+0000',
+            customBitlinks: [],
+            references: {
+              group: 'Ba1bc23dE4F',
+            },
+            rawLinkData: {
+              id: 'bit.ly/test123',
+              link: 'https://bit.ly/test123',
+              long_url: 'https://example.com/very-long-url',
+              title: 'Sample Bitlink',
+              tags: ['sample', 'test'],
+              archived: false,
+              created_at: '2025-01-15T10:00:00+0000',
+              modified_at: '2025-01-15T10:00:00+0000',
+              custom_bitlinks: [],
+              references: {
+                group: 'Ba1bc23dE4F',
+              },
+            },
+            triggerInfo: {
+              detectedAt: new Date().toISOString(),
+              source: 'bitly',
+              type: 'new_bitlink',
+            },
+          },
+        ];
+      }
+    } catch (error: any) {
+      return [
+        {
+          id: 'bit.ly/test123',
+          link: 'https://bit.ly/test123',
+          longUrl: 'https://example.com/test-url',
+          title: 'Test Bitlink',
+          tags: ['test'],
+          isArchived: false,
+          createdAt: '2025-01-15T10:00:00+0000',
+          modifiedAt: '2025-01-15T10:00:00+0000',
+          customBitlinks: [],
+          references: {
+            group: 'Ba1bc23dE4F',
+          },
+          rawLinkData: {
+            id: 'bit.ly/test123',
+            link: 'https://bit.ly/test123',
+            long_url: 'https://example.com/test-url',
+            title: 'Test Bitlink',
+            tags: ['test'],
+            archived: false,
+            created_at: '2025-01-15T10:00:00+0000',
+            modified_at: '2025-01-15T10:00:00+0000',
+            custom_bitlinks: [],
+            references: {
+              group: 'Ba1bc23dE4F',
+            },
+          },
+          triggerInfo: {
+            detectedAt: new Date().toISOString(),
+            source: 'bitly',
+            type: 'new_bitlink',
+          },
+        },
+      ];
+    }
+  },
+
+  sampleData: {
+    id: 'bit.ly/3XYZ123',
+    link: 'https://bit.ly/3XYZ123',
+    longUrl: 'https://example.com/marketing-campaign-landing-page',
+    title: 'Marketing Campaign Landing Page',
+    tags: ['marketing', 'campaign', '2025'],
+    isArchived: false,
+    createdAt: '2025-01-15T09:30:00+0000',
+    modifiedAt: '2025-01-15T09:30:00+0000',
+    customBitlinks: [],
+    references: {
+      group: 'Ba1bc23dE4F',
+    },
+    rawLinkData: {
+      id: 'bit.ly/3XYZ123',
+      link: 'https://bit.ly/3XYZ123',
+      long_url: 'https://example.com/marketing-campaign-landing-page',
+      title: 'Marketing Campaign Landing Page',
+      tags: ['marketing', 'campaign', '2025'],
+      archived: false,
+      created_at: '2025-01-15T09:30:00+0000',
+      modified_at: '2025-01-15T09:30:00+0000',
+      custom_bitlinks: [],
+      references: {
+        group: 'Ba1bc23dE4F',
+      },
+    },
+    triggerInfo: {
+      detectedAt: '2025-01-15T09:30:00.000Z',
+      source: 'bitly',
+      type: 'new_bitlink',
+    },
+  },
+});
+
+/**
+ * Interface for Bitly link data structure
+ */
+interface BitlyLink {
+  id: string;
+  link: string;
+  long_url: string;
+  title: string;
+  tags: string[];
+  archived: boolean;
+  created_at: string;
+  modified_at: string;
+  custom_bitlinks: string[];
+  references: {
+    group: string;
+  };
+  [key: string]: any;
+}