@guayaba/workflow-piece-google-cloud-storage 0.1.3

package/src/lib/actions/search-objects.ts

@@ -0,0 +1,99 @@
+import { createAction, Property, OAuth2PropertyValue } from '@guayaba/workflows-framework';
+import { googleCloudStorageAuth } from '../common/auth';
+import { gcsCommon } from '../common/client';
+import { bucketDropdown, projectIdProperty } from '../common/props';
+import { HttpMethod } from '@guayaba/workflows-common';
+
+export const searchObjects = createAction({
+  auth: googleCloudStorageAuth,
+  name: 'search_objects',
+  displayName: 'Search Objects',
+  description: 'Search objects by criteria. Perfect for finding files in your bucket.',
+  props: {
+    projectId: projectIdProperty,
+    bucket: bucketDropdown,
+    prefix: Property.ShortText({
+      displayName: 'Prefix',
+      description: 'Filter objects whose names begin with this prefix',
+      required: false,
+    }),
+    matchGlob: Property.ShortText({
+      displayName: 'Glob Pattern',
+      description: 'Glob pattern to filter results (e.g., "folder/*", "backup-*.txt")',
+      required: false,
+    }),
+    delimiter: Property.ShortText({
+      displayName: 'Delimiter',
+      description: 'Delimiter for hierarchical listing (commonly "/")',
+      required: false,
+    }),
+    includeFoldersAsPrefixes: Property.Checkbox({
+      displayName: 'Include Folders',
+      description: 'Include empty folders and managed folders in results',
+      required: false,
+    }),
+    versions: Property.Checkbox({
+      displayName: 'Include Versions',
+      description: 'List all versions of objects as distinct results',
+      required: false,
+    }),
+    pageToken: Property.ShortText({
+      displayName: 'Page Token',
+      description: 'Token for pagination (from previous response)',
+      required: false,
+    }),
+    maxResults: Property.Number({
+      displayName: 'Max Results',
+      description: 'Maximum number of objects to return (recommended: ≤1000)',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const {
+      bucket,
+      prefix,
+      matchGlob,
+      delimiter,
+      includeFoldersAsPrefixes,
+      versions,
+      pageToken,
+      maxResults
+    } = context.propsValue;
+    const auth = context.auth as OAuth2PropertyValue;
+
+    const params = new URLSearchParams();
+    if (prefix) params.append('prefix', prefix);
+    if (matchGlob) params.append('matchGlob', matchGlob);
+    if (delimiter) params.append('delimiter', delimiter);
+    if (includeFoldersAsPrefixes) params.append('includeFoldersAsPrefixes', 'true');
+    if (versions) params.append('versions', 'true');
+    if (pageToken) params.append('pageToken', pageToken);
+    if (maxResults) params.append('maxResults', maxResults.toString());
+
+    const path = `/b/${bucket}/o?${params.toString()}`;
+
+    try {
+      const response = await gcsCommon.makeRequest(HttpMethod.GET, path, auth.access_token);
+
+      return {
+        success: true,
+        bucket,
+        items: response.items || [],
+        nextPageToken: response.nextPageToken,
+        prefixes: response.prefixes || [],
+        totalItems: response.items?.length || 0,
+      };
+    } catch (error: any) {
+      if (error.response?.status === 403) {
+        throw new Error('Access denied. You need storage.objects.list permission to search objects in this bucket.');
+      }
+      if (error.response?.status === 404) {
+        throw new Error(`Bucket "${bucket}" not found.`);
+      }
+      if (error.response?.status === 400) {
+        throw new Error('Invalid search parameters. Check your prefix, glob pattern, or other filters.');
+      }
+      throw new Error(`Failed to search objects: ${error.message || 'Unknown error'}`);
+    }
+  },
+});

package/src/lib/common/auth.ts

@@ -0,0 +1,14 @@
+import { PieceAuth } from '@guayaba/workflows-framework';
+
+export const googleCloudStorageAuth = PieceAuth.OAuth2({
+  description: '',
+  authUrl: 'https://accounts.google.com/o/oauth2/auth',
+  tokenUrl: 'https://oauth2.googleapis.com/token',
+  required: true,
+  scope: [
+    'https://www.googleapis.com/auth/devstorage.read_write',
+    'https://www.googleapis.com/auth/devstorage.full_control',
+    'https://www.googleapis.com/auth/cloud-platform.read-only',
+    'https://www.googleapis.com/auth/pubsub'
+  ],
+});

package/src/lib/common/client.ts

@@ -0,0 +1,63 @@
+import {
+  httpClient,
+  HttpMethod,
+  AuthenticationType,
+} from '@guayaba/workflows-common';
+import { OAuth2PropertyValue } from '@guayaba/workflows-framework';
+
+export const gcsCommon = {
+  gcsBaseUrl: 'https://www.googleapis.com/storage/v1',
+  pubsubBaseUrl: 'https://pubsub.googleapis.com/v1',
+
+  async makeGCSRequest(
+    method: HttpMethod,
+    path: string,
+    accessToken: string,
+    body?: any
+  ): Promise<any> {
+    const url = path.startsWith('http') ? path : `${this.gcsBaseUrl}${path}`;
+
+    const response = await httpClient.sendRequest({
+      method,
+      url,
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: accessToken,
+      },
+      body,
+    });
+
+    return response.body;
+  },
+
+  async makePubSubRequest(
+    method: HttpMethod,
+    path: string,
+    accessToken: string,
+    body?: any
+  ): Promise<any> {
+    const url = path.startsWith('http') ? path : `${this.pubsubBaseUrl}${path}`;
+
+    const response = await httpClient.sendRequest({
+      method,
+      url,
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: accessToken,
+      },
+      body,
+    });
+
+    return response.body;
+  },
+
+  // For backward compatibility
+  async makeRequest(
+    method: HttpMethod,
+    path: string,
+    accessToken: string,
+    body?: any
+  ): Promise<any> {
+    return this.makeGCSRequest(method, path, accessToken, body);
+  },
+};

package/src/lib/common/props.ts

@@ -0,0 +1,249 @@
+import { Property, OAuth2PropertyValue } from '@guayaba/workflows-framework';
+import { gcsCommon } from './client';
+import { HttpMethod } from '@guayaba/workflows-common';
+import { googleCloudStorageAuth } from './auth';
+
+export const bucketDropdown = Property.Dropdown<string,true,typeof googleCloudStorageAuth>({
+  displayName: 'Bucket',
+  required: true,
+  refreshers: ['projectId'],
+  auth: googleCloudStorageAuth,
+  options: async ({ auth, projectId }) => {
+    if (!auth || !projectId) {
+      return {
+        disabled: true,
+        options: [],
+        placeholder: projectId
+          ? 'Please connect your account first'
+          : 'Please enter project ID first',
+      };
+    }
+
+    try {
+      const authValue = auth as OAuth2PropertyValue;
+      const response = await gcsCommon.makeRequest(
+        HttpMethod.GET,
+        `/b?project=${projectId}`,
+        authValue.access_token
+      );
+
+      return {
+        disabled: false,
+        options:
+          response.items?.map((bucket: any) => ({
+            label: bucket.name,
+            value: bucket.name,
+          })) || [],
+      };
+    } catch (error) {
+      return {
+        disabled: true,
+        options: [],
+        placeholder: 'Failed to load buckets',
+      };
+    }
+  },
+});
+
+export const objectDropdown = (bucketProperty: string) =>
+  Property.Dropdown<string,true,typeof googleCloudStorageAuth>({
+    displayName: 'Object',
+    required: true,   
+    auth: googleCloudStorageAuth,
+    refreshers: [bucketProperty],
+    options: async ({ auth, [bucketProperty]: bucket }) => {
+      if (!auth || !bucket) {
+        return {
+          disabled: true,
+          options: [],
+          placeholder: bucket
+            ? 'Please connect your account first'
+            : 'Please select a bucket first',
+        };
+      }
+
+      try {
+        const authValue = auth as OAuth2PropertyValue;
+        const response = await gcsCommon.makeRequest(
+          HttpMethod.GET,
+          `/b/${bucket}/o?maxResults=100`,
+          authValue.access_token
+        );
+
+        return {
+          disabled: false,
+          options:
+            response.items?.map((object: any) => ({
+              label: object.name,
+              value: object.name,
+            })) || [],
+        };
+      } catch (error) {
+        return {
+          disabled: true,
+          options: [],
+          placeholder: 'Failed to load objects',
+        };
+      }
+    },
+  });
+
+export const projectIdProperty = Property.Dropdown<string,true,typeof googleCloudStorageAuth>({
+  displayName: 'Project',
+  required: true,
+  auth: googleCloudStorageAuth,
+  refreshers: [],
+  options: async ({ auth }) => {
+    if (!auth) {
+      return {
+        disabled: true,
+        options: [],
+        placeholder: 'Please connect your account first',
+      };
+    }
+
+    try {
+      const authValue = auth as OAuth2PropertyValue;
+      // Use Google Cloud Resource Manager API to list projects
+      const response = await gcsCommon.makeRequest(
+        HttpMethod.GET,
+        'https://cloudresourcemanager.googleapis.com/v1/projects?filter=lifecycleState:ACTIVE',
+        authValue.access_token
+      );
+
+      return {
+        disabled: false,
+        options: response.projects?.map((project: any) => ({
+          label: `${project.displayName || project.name} (${project.projectId})`,
+          value: project.projectId,
+        })) || [],
+      };
+    } catch (error) {
+      return {
+        disabled: true,
+        options: [],
+        placeholder: 'Failed to load projects. Check your permissions.',
+      };
+    }
+  },
+});
+
+export const bucketNameProperty = Property.ShortText({
+  displayName: 'Bucket Name',
+  description: 'Unique name for your bucket (must be globally unique, 3-63 characters)',
+  required: true,
+});
+
+export const objectNameProperty = Property.ShortText({
+  displayName: 'Object Name',
+  required: true,
+});
+
+export const locationProperty = Property.StaticDropdown({
+  displayName: 'Location',
+  required: false,
+  options: {
+    options: [
+      // Multi-region
+      { label: 'US (Multi-region)', value: 'US' },
+      { label: 'EU (Multi-region)', value: 'EU' },
+      { label: 'ASIA (Multi-region)', value: 'ASIA' },
+      // US regions
+      { label: 'us-central1 (Iowa)', value: 'us-central1' },
+      { label: 'us-east1 (South Carolina)', value: 'us-east1' },
+      { label: 'us-east4 (Northern Virginia)', value: 'us-east4' },
+      { label: 'us-west1 (Oregon)', value: 'us-west1' },
+      { label: 'us-west2 (Los Angeles)', value: 'us-west2' },
+      { label: 'us-west3 (Salt Lake City)', value: 'us-west3' },
+      { label: 'us-west4 (Las Vegas)', value: 'us-west4' },
+      { label: 'us-south1 (Dallas)', value: 'us-south1' },
+      // Europe regions
+      { label: 'europe-central2 (Warsaw)', value: 'europe-central2' },
+      { label: 'europe-north1 (Finland)', value: 'europe-north1' },
+      { label: 'europe-southwest1 (Madrid)', value: 'europe-southwest1' },
+      { label: 'europe-west1 (Belgium)', value: 'europe-west1' },
+      { label: 'europe-west2 (London)', value: 'europe-west2' },
+      { label: 'europe-west3 (Frankfurt)', value: 'europe-west3' },
+      { label: 'europe-west4 (Netherlands)', value: 'europe-west4' },
+      { label: 'europe-west6 (Zurich)', value: 'europe-west6' },
+      { label: 'europe-west8 (Milan)', value: 'europe-west8' },
+      { label: 'europe-west9 (Paris)', value: 'europe-west9' },
+      // Asia regions
+      { label: 'asia-east1 (Taiwan)', value: 'asia-east1' },
+      { label: 'asia-east2 (Hong Kong)', value: 'asia-east2' },
+      { label: 'asia-northeast1 (Tokyo)', value: 'asia-northeast1' },
+      { label: 'asia-northeast2 (Osaka)', value: 'asia-northeast2' },
+      { label: 'asia-northeast3 (Seoul)', value: 'asia-northeast3' },
+      { label: 'asia-south1 (Mumbai)', value: 'asia-south1' },
+      { label: 'asia-south2 (Delhi)', value: 'asia-south2' },
+      { label: 'asia-southeast1 (Singapore)', value: 'asia-southeast1' },
+      { label: 'asia-southeast2 (Jakarta)', value: 'asia-southeast2' },
+      // Other regions
+      { label: 'australia-southeast1 (Sydney)', value: 'australia-southeast1' },
+      { label: 'australia-southeast2 (Melbourne)', value: 'australia-southeast2' },
+      { label: 'northamerica-northeast1 (Montreal)', value: 'northamerica-northeast1' },
+      { label: 'northamerica-northeast2 (Toronto)', value: 'northamerica-northeast2' },
+      { label: 'southamerica-east1 (São Paulo)', value: 'southamerica-east1' },
+      { label: 'southamerica-west1 (Santiago)', value: 'southamerica-west1' },
+    ],
+  },
+});
+
+export const storageClassProperty = Property.StaticDropdown({
+  displayName: 'Storage Class',
+  required: false,
+  options: {
+    options: [
+      { label: 'Standard', value: 'STANDARD' },
+      { label: 'Nearline', value: 'NEARLINE' },
+      { label: 'Coldline', value: 'COLDLINE' },
+      { label: 'Archive', value: 'ARCHIVE' },
+      { label: 'Multi-regional', value: 'MULTI_REGIONAL' },
+      { label: 'Regional', value: 'REGIONAL' },
+      { label: 'Durable Reduced Availability', value: 'DURABLE_REDUCED_AVAILABILITY' },
+    ],
+  },
+});
+
+export const aclEntityProperty = Property.ShortText({
+  displayName: 'Entity',
+  description: 'The entity to grant access to. Must include the entity type prefix. Format: user-emailAddress, group-groupId, group-emailAddress, domain-domainName, project-team-projectId, allUsers, or allAuthenticatedUsers. Examples: user-liz@example.com, group-mygroup@googlegroups.com, domain-example.com, allUsers',
+  required: true,
+});
+
+export const aclRoleProperty = Property.StaticDropdown({
+  displayName: 'Role',
+  required: true,
+  options: {
+    options: [
+      { label: 'Reader', value: 'READER' },
+      { label: 'Writer', value: 'WRITER' },
+      { label: 'Owner', value: 'OWNER' },
+    ],
+  },
+});
+
+// For bucket ACLs - supports OWNER, WRITER, READER
+export const bucketAclRoleProperty = Property.StaticDropdown({
+  displayName: 'Role',
+  required: true,
+  options: {
+    options: [
+      { label: 'Reader', value: 'READER' },
+      { label: 'Writer', value: 'WRITER' },
+      { label: 'Owner', value: 'OWNER' },
+    ],
+  },
+});
+
+// For object ACLs - supports OWNER, READER only
+export const objectAclRoleProperty = Property.StaticDropdown({
+  displayName: 'Role',
+  required: true,
+  options: {
+    options: [
+      { label: 'Reader', value: 'READER' },
+      { label: 'Owner', value: 'OWNER' },
+    ],
+  },
+});

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

@@ -0,0 +1,171 @@
+import { createTrigger, TriggerStrategy, Property } from '@guayaba/workflows-framework';
+import { googleCloudStorageAuth } from '../common/auth';
+import { gcsCommon } from '../common/client';
+import { bucketDropdown, projectIdProperty } from '../common/props';
+import { HttpMethod } from '@guayaba/workflows-common';
+
+interface TriggerData {
+  topicName: string;
+  subscriptionName: string;
+  notificationId: string;
+}
+
+export const newObjectCreated = createTrigger({
+  auth: googleCloudStorageAuth,
+  name: 'new_object_created',
+  displayName: 'New Object Created',
+  description: 'Triggers when a new object is created in a bucket',
+  props: {
+    projectId: projectIdProperty,
+    bucket: bucketDropdown,
+    prefix: Property.ShortText({
+      displayName: 'Prefix Filter',
+      description: 'Only trigger for objects with this prefix',
+      required: false,
+    }),
+  },
+  type: TriggerStrategy.WEBHOOK,
+  sampleData: {
+    kind: 'storage#object',
+    id: 'example-bucket/example-object/1234567890',
+    name: 'example-object.txt',
+    bucket: 'example-bucket',
+    generation: '1234567890',
+    contentType: 'text/plain',
+    timeCreated: '2023-01-01T00:00:00.000Z',
+    updated: '2023-01-01T00:00:00.000Z',
+    size: '1024',
+  },
+  onEnable: async (context) => {
+    const { projectId, bucket, prefix } = context.propsValue;
+    const auth = context.auth;
+
+    // Generate unique names for this trigger instance
+    const triggerId = `ap-gcs-${bucket}-${Date.now()}`;
+    const topicName = `projects/${projectId}/topics/${triggerId}`;
+    const subscriptionName = `projects/${projectId}/subscriptions/${triggerId}`;
+
+    try {
+      // 1. Create Pub/Sub topic
+      await gcsCommon.makePubSubRequest(
+        HttpMethod.PUT,
+        `/projects/${projectId}/topics/${triggerId}`,
+        auth.access_token
+      );
+
+      // 2. Create GCS notification configuration
+      const notificationConfig: any = {
+        topic: topicName,
+        payload_format: 'JSON_API_V1',
+        event_types: ['OBJECT_FINALIZE'],
+      };
+
+      if (prefix) {
+        notificationConfig.object_name_prefix = prefix;
+      }
+
+      const notificationResponse = await gcsCommon.makeGCSRequest(
+        HttpMethod.POST,
+        `/b/${bucket}/notificationConfigs`,
+        auth.access_token,
+        notificationConfig
+      );
+
+      // 3. Create Pub/Sub subscription with webhook push
+      const subscriptionConfig = {
+        topic: topicName,
+        pushConfig: {
+          pushEndpoint: context.webhookUrl,
+        },
+        ackDeadlineSeconds: 60,
+      };
+
+      await gcsCommon.makePubSubRequest(
+        HttpMethod.PUT,
+        `/projects/${projectId}/subscriptions/${triggerId}`,
+        auth.access_token,
+        subscriptionConfig
+      );
+
+      // Store trigger data for cleanup
+      await context.store.put<TriggerData>('_trigger', {
+        topicName: triggerId,
+        subscriptionName: triggerId,
+        notificationId: notificationResponse.id,
+      });
+
+    } catch (error) {
+      // Cleanup on failure
+      try {
+        await gcsCommon.makePubSubRequest(
+          HttpMethod.DELETE,
+          `/projects/${projectId}/subscriptions/${triggerId}`,
+          auth.access_token
+        );
+      } catch (e) { /* ignore */ }
+
+      try {
+        await gcsCommon.makePubSubRequest(
+          HttpMethod.DELETE,
+          `/projects/${projectId}/topics/${triggerId}`,
+          auth.access_token
+        );
+      } catch (e) { /* ignore */ }
+
+      throw new Error(`Failed to setup Pub/Sub notifications: ${(error as any)?.message || 'Unknown error'}`);
+    }
+  },
+  onDisable: async (context) => {
+    const triggerData = await context.store.get<TriggerData>('_trigger');
+    if (!triggerData) return;
+
+    const { projectId } = context.propsValue;
+    const { bucket } = context.propsValue;
+    const auth = context.auth;
+
+    // Clean up in reverse order
+    try {
+      // Delete subscription
+      await gcsCommon.makePubSubRequest(
+        HttpMethod.DELETE,
+        `/projects/${projectId}/subscriptions/${triggerData.subscriptionName}`,
+        auth.access_token
+      );
+    } catch (e) { /* ignore */ }
+
+    try {
+      // Delete notification config
+      await gcsCommon.makeGCSRequest(
+        HttpMethod.DELETE,
+        `/b/${bucket}/notificationConfigs/${triggerData.notificationId}`,
+        auth.access_token
+      );
+    } catch (e) { /* ignore */ }
+
+    try {
+      // Delete topic
+      await gcsCommon.makePubSubRequest(
+        HttpMethod.DELETE,
+        `/projects/${projectId}/topics/${triggerData.topicName}`,
+        auth.access_token
+      );
+    } catch (e) { /* ignore */ }
+  },
+  run: async (context) => {
+    const payload = context.payload.body as any;
+
+    if (!payload?.message?.data) {
+      return [];
+    }
+
+    // Decode Pub/Sub message
+    const messageData = JSON.parse(
+      Buffer.from(payload.message.data, 'base64').toString()
+    );
+
+    // Extract GCS object from notification payload
+    const gcsObject = messageData;
+
+    return [gcsObject];
+  },
+});