@divyacon/piece-google-cloud-storage 0.0.0-stage → 0.1.1

package/src/lib/common/props.ts

@@ -0,0 +1,249 @@
+import { Property, OAuth2PropertyValue } from '@agnocon/pieces-framework';
+import { gcsCommon } from './client';
+import { HttpMethod } from '@agnocon/pieces-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,174 @@
+import { createTrigger, TriggerStrategy, Property } from '@agnocon/pieces-framework';
+import { googleCloudStorageAuth } from '../common/auth';
+import { gcsCommon } from '../common/client';
+import { bucketDropdown, projectIdProperty } from '../common/props';
+import { HttpMethod } from '@agnocon/pieces-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',
+  aiMetadata: {
+    description: 'Fires when a new object is finalized (fully written) in the configured bucket, optionally limited to objects whose name starts with a given prefix. Represents a newly created/uploaded file; delivered via a Cloud Pub/Sub push notification (OBJECT_FINALIZE event).',
+  },
+  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];
+  },
+});

package/src/lib/triggers/object-updated.ts

@@ -0,0 +1,174 @@
+import { createTrigger, TriggerStrategy, Property } from '@agnocon/pieces-framework';
+import { googleCloudStorageAuth } from '../common/auth';
+import { gcsCommon } from '../common/client';
+import { bucketDropdown, projectIdProperty } from '../common/props';
+import { HttpMethod } from '@agnocon/pieces-common';
+
+interface TriggerData {
+  topicName: string;
+  subscriptionName: string;
+  notificationId: string;
+}
+
+export const objectUpdated = createTrigger({
+  auth: googleCloudStorageAuth,
+  name: 'object_updated',
+  displayName: 'Object Updated',
+  description: 'Triggers when an existing object is updated in a bucket',
+  aiMetadata: {
+    description: 'Fires when the metadata of an existing object in the configured bucket is updated, optionally limited to objects whose name starts with a given prefix. Represents a change to an existing file\'s metadata; delivered via a Cloud Pub/Sub push notification (OBJECT_METADATA_UPDATE event).',
+  },
+  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-01T01:00:00.000Z',
+    size: '2048',
+  },
+  onEnable: async (context) => {
+    const { projectId, bucket, prefix } = context.propsValue;
+    const auth = context.auth;
+
+    // Generate unique names for this trigger instance
+    const triggerId = `ap-gcs-update-${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 for metadata updates
+      const notificationConfig: any = {
+        topic: topicName,
+        payload_format: 'JSON_API_V1',
+        event_types: ['OBJECT_METADATA_UPDATE'],
+      };
+
+      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];
+  },
+});

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.