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

package/src/lib/actions/delete-bucket-default-object-acl.ts

@@ -0,0 +1,52 @@
+import { createAction, OAuth2PropertyValue } from '@agnocon/pieces-framework';
+import { googleCloudStorageAuth } from '../common/auth';
+import { gcsCommon } from '../common/client';
+import { bucketDropdown, aclEntityProperty, projectIdProperty } from '../common/props';
+import { HttpMethod } from '@agnocon/pieces-common';
+
+export const deleteBucketDefaultObjectAcl = createAction({
+  auth: googleCloudStorageAuth,
+  name: 'delete_bucket_default_object_acl',
+  displayName: 'Delete Bucket Default Object ACL',
+  description: 'Remove default ACL settings from a bucket. Perfect for reverting to default behavior.',
+  audience: 'both',
+  aiMetadata: { description: 'Removes an entity\'s entry from a bucket\'s default object ACL, so it no longer applies to future uploads. Use to revert a default-permission rule for new objects. Not idempotent: the first call removes the entry and a repeat fails because it no longer exists, and it does not affect already-uploaded objects. Only works on buckets using fine-grained ACLs, not uniform bucket-level access; requires bucket and entity.', idempotent: false },
+  props: {
+    projectId: projectIdProperty,
+    bucket: bucketDropdown,
+    entity: aclEntityProperty,
+  },
+  async run(context) {
+    const { bucket, entity } = context.propsValue;
+    const auth = context.auth as OAuth2PropertyValue;
+
+    try {
+      await gcsCommon.makeRequest(
+        HttpMethod.DELETE,
+        `/b/${bucket}/defaultObjectAcl/${encodeURIComponent(entity)}`,
+        auth.access_token
+      );
+
+      return {
+        success: true,
+        bucket,
+        entity,
+        message: `Default object ACL entry for entity "${entity}" removed successfully from bucket "${bucket}"`,
+      };
+    } catch (error: any) {
+      if (error.response?.status === 400) {
+        throw new Error('Bad request. This bucket may have uniform bucket-level access enabled, which doesn\'t support default object ACLs. Use IAM policies instead.');
+      }
+      if (error.response?.status === 403) {
+        throw new Error('Access denied. You need storage.buckets.update permission to modify bucket default object ACLs.');
+      }
+      if (error.response?.status === 404) {
+        if (error.response?.data?.error?.message?.includes('ACL')) {
+          throw new Error(`Default object ACL entry for entity "${entity}" not found on bucket "${bucket}".`);
+        }
+        throw new Error(`Bucket "${bucket}" not found.`);
+      }
+      throw new Error(`Failed to delete bucket default object ACL: ${error.message || 'Unknown error'}`);
+    }
+  },
+});

package/src/lib/actions/delete-empty-bucket.ts

@@ -0,0 +1,42 @@
+import { createAction, OAuth2PropertyValue } 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';
+
+export const deleteEmptyBucket = createAction({
+  auth: googleCloudStorageAuth,
+  name: 'delete_empty_bucket',
+  displayName: 'Delete Empty Bucket',
+  description: 'Clean up unused buckets by deleting them if they contain no live objects.',
+  audience: 'both',
+  aiMetadata: { description: 'Permanently deletes a Cloud Storage bucket. Use to clean up an unused bucket. The bucket must be empty (no live or noncurrent objects) or the call fails, so delete its objects first. Not idempotent: the first call removes the bucket and a repeat fails because it no longer exists.', idempotent: false },
+  props: {
+    projectId: projectIdProperty,
+    bucket: bucketDropdown,
+  },
+  async run(context) {
+    const { bucket } = context.propsValue;
+    const auth = context.auth as OAuth2PropertyValue;
+
+    try {
+      await gcsCommon.makeRequest(HttpMethod.DELETE, `/b/${bucket}`, auth.access_token);
+
+      return {
+        success: true,
+        message: `Bucket "${bucket}" deleted successfully`,
+      };
+    } catch (error: any) {
+      if (error.response?.status === 409) {
+        throw new Error(`Bucket "${bucket}" contains live or noncurrent objects and cannot be deleted. Remove all objects first.`);
+      }
+      if (error.response?.status === 403) {
+        throw new Error('Access denied. You need storage.buckets.delete permission to delete this bucket.');
+      }
+      if (error.response?.status === 404) {
+        throw new Error(`Bucket "${bucket}" not found. It may have already been deleted.`);
+      }
+      throw new Error(`Failed to delete bucket: ${error.message || 'Unknown error'}`);
+    }
+  },
+});

package/src/lib/actions/delete-object-acl.ts

@@ -0,0 +1,64 @@
+import { createAction, Property, OAuth2PropertyValue } from '@agnocon/pieces-framework';
+import { googleCloudStorageAuth } from '../common/auth';
+import { gcsCommon } from '../common/client';
+import { bucketDropdown, objectDropdown, aclEntityProperty, projectIdProperty } from '../common/props';
+import { HttpMethod } from '@agnocon/pieces-common';
+
+export const deleteObjectAcl = createAction({
+  auth: googleCloudStorageAuth,
+  name: 'delete_object_acl',
+  displayName: 'Delete Object ACL',
+  description: 'Remove an ACL entry from an object. Perfect for revoking access for a user.',
+  audience: 'both',
+  aiMetadata: { description: 'Removes an entity\'s entry from a single object\'s access-control list, optionally targeting a specific generation. Use to revoke a user or group\'s access to one file. Not idempotent: the first call removes the entry and a repeat fails because it no longer exists. Only works on buckets using fine-grained ACLs, not uniform bucket-level access; requires bucket, object, and entity.', idempotent: false },
+  props: {
+    projectId: projectIdProperty,
+    bucket: bucketDropdown,
+    object: objectDropdown('bucket'),
+    entity: aclEntityProperty,
+    generation: Property.Number({
+      displayName: 'Generation',
+      description: 'Optional generation number for versioned objects',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const { bucket, object, entity, generation } = context.propsValue;
+    const auth = context.auth as OAuth2PropertyValue;
+
+    let path = `/b/${bucket}/o/${encodeURIComponent(object as string)}/acl/${encodeURIComponent(entity as string)}`;
+    if (generation) {
+      path += `?generation=${generation}`;
+    }
+
+    try {
+      await gcsCommon.makeRequest(HttpMethod.DELETE, path, auth.access_token);
+
+      return {
+        success: true,
+        bucket,
+        object,
+        entity,
+        generation: generation || 'latest',
+        message: `ACL entry for entity "${entity}" removed successfully from object "${object}"`,
+      };
+    } catch (error: any) {
+      if (error.response?.status === 400) {
+        if (entity.includes('user-') && entity.includes('@')) {
+          throw new Error('Cannot remove OWNER access from the object owner. The only way to remove owner access is to delete or replace the object.');
+        }
+        throw new Error('Bad request. This bucket may have uniform bucket-level access enabled, which doesn\'t support object ACLs. Use IAM policies instead.');
+      }
+      if (error.response?.status === 403) {
+        throw new Error('Access denied. You need storage.objects.setIamPolicy permission or OWNER ACL permission on the object.');
+      }
+      if (error.response?.status === 404) {
+        if (error.response?.data?.error?.message?.includes('ACL')) {
+          throw new Error(`ACL entry for entity "${entity}" not found on object "${object}".`);
+        }
+        throw new Error(`Object "${object}" not found in bucket "${bucket}".`);
+      }
+      throw new Error(`Failed to delete object ACL: ${error.message || 'Unknown error'}`);
+    }
+  },
+});

package/src/lib/actions/delete-object.ts

@@ -0,0 +1,59 @@
+import { createAction, Property, OAuth2PropertyValue } from '@agnocon/pieces-framework';
+import { googleCloudStorageAuth } from '../common/auth';
+import { gcsCommon } from '../common/client';
+import { bucketDropdown, objectDropdown, projectIdProperty } from '../common/props';
+import { HttpMethod } from '@agnocon/pieces-common';
+
+export const deleteObject = createAction({
+  auth: googleCloudStorageAuth,
+  name: 'delete_object',
+  displayName: 'Delete Object',
+  description: 'Permanently delete a specific object. Perfect for removing obsolete files.',
+  audience: 'both',
+  aiMetadata: { description: 'Permanently deletes an object from a bucket, optionally a specific generation/revision for versioned objects. Use to remove an obsolete or unwanted file. Not idempotent: the first call removes the object and a repeat fails because it no longer exists. Requires the bucket and object name.', idempotent: false },
+  props: {
+    projectId: projectIdProperty,
+    bucket: bucketDropdown,
+    object: objectDropdown('bucket'),
+    generation: Property.Number({
+      displayName: 'Generation',
+      description: 'Optional generation number for versioned objects (permanently deletes a specific revision)',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const { bucket, object, generation } = context.propsValue;
+    const auth = context.auth as OAuth2PropertyValue;
+
+    let path = `/b/${bucket}/o/${encodeURIComponent(object as string)}`;
+    if (generation) {
+      path += `?generation=${generation}`;
+    }
+
+    try {
+      await gcsCommon.makeRequest(HttpMethod.DELETE, path, auth.access_token);
+
+      return {
+        success: true,
+        bucket,
+        object,
+        generation: generation || 'latest',
+        message: `Object "${object}" deleted successfully from bucket "${bucket}"`,
+      };
+    } catch (error: any) {
+      if (error.response?.status === 404) {
+        throw new Error(`Object "${object}" not found in bucket "${bucket}". It may have already been deleted.`);
+      }
+      if (error.response?.status === 403) {
+        throw new Error('Access denied. You need storage.objects.delete permission to delete this object.');
+      }
+      if (error.response?.status === 412) {
+        throw new Error('Precondition failed. Object may have been modified or deleted by another process.');
+      }
+      if (error.response?.status === 400) {
+        throw new Error('Invalid request. Check object name and generation parameters.');
+      }
+      throw new Error(`Failed to delete object: ${error.message || 'Unknown error'}`);
+    }
+  },
+});

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

@@ -0,0 +1,92 @@
+import { createAction, Property, OAuth2PropertyValue } from '@agnocon/pieces-framework';
+import { googleCloudStorageAuth } from '../common/auth';
+import { gcsCommon } from '../common/client';
+import { projectIdProperty } from '../common/props';
+import { HttpMethod } from '@agnocon/pieces-common';
+
+export const searchBuckets = createAction({
+  auth: googleCloudStorageAuth,
+  name: 'search_buckets',
+  displayName: 'Search Buckets',
+  description: 'Search buckets by name. Perfect for finding buckets in your project.',
+  audience: 'both',
+  aiMetadata: { description: 'Lists buckets in a project, optionally filtered by name prefix, including soft-deleted versions, and choosing whether ACLs are returned; with no prefix it returns all buckets. Use to find a bucket or enumerate a project\'s buckets, and pass the returned page token to paginate. Idempotent read that does not modify storage. Requires the project ID.', idempotent: true },
+  props: {
+    projectId: projectIdProperty,
+    prefix: Property.ShortText({
+      displayName: 'Name Prefix',
+      description: 'Filter buckets whose names begin with this prefix',
+      required: false,
+    }),
+    includeSoftDeleted: Property.Checkbox({
+      displayName: 'Include Soft-Deleted',
+      description: 'Include soft-deleted bucket versions in results',
+      required: false,
+    }),
+    projection: Property.StaticDropdown({
+      displayName: 'Projection',
+      description: 'Set of properties to return',
+      required: false,
+      options: {
+        options: [
+          { label: 'No ACLs (faster)', value: 'noAcl' },
+          { label: 'Full (includes ACLs)', value: 'full' },
+        ],
+      },
+    }),
+    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 buckets to return',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const {
+      projectId,
+      prefix,
+      includeSoftDeleted,
+      projection,
+      pageToken,
+      maxResults
+    } = context.propsValue;
+    const auth = context.auth as OAuth2PropertyValue;
+
+    const params = new URLSearchParams();
+    params.append('project', projectId!);
+    if (prefix) params.append('prefix', prefix);
+    if (includeSoftDeleted) params.append('softDeleted', 'true');
+    if (projection) params.append('projection', projection);
+    if (pageToken) params.append('pageToken', pageToken);
+    if (maxResults) params.append('maxResults', maxResults.toString());
+
+    const path = `/b?${params.toString()}`;
+
+    try {
+      const response = await gcsCommon.makeRequest(HttpMethod.GET, path, auth.access_token);
+
+      return {
+        success: true,
+        projectId,
+        items: response.items || [],
+        nextPageToken: response.nextPageToken,
+        totalBuckets: response.items?.length || 0,
+      };
+    } catch (error: any) {
+      if (error.response?.status === 403) {
+        throw new Error('Access denied. You need storage.buckets.list permission to search buckets in this project.');
+      }
+      if (error.response?.status === 404) {
+        throw new Error(`Project "${projectId}" not found or you don't have access to it.`);
+      }
+      if (error.response?.status === 400) {
+        throw new Error('Invalid search parameters. Check your project ID and other filters.');
+      }
+      throw new Error(`Failed to search buckets: ${error.message || 'Unknown error'}`);
+    }
+  },
+});

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

@@ -0,0 +1,101 @@
+import { createAction, Property, OAuth2PropertyValue } 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';
+
+export const searchObjects = createAction({
+  auth: googleCloudStorageAuth,
+  name: 'search_objects',
+  displayName: 'Search Objects',
+  description: 'Search objects by criteria. Perfect for finding files in your bucket.',
+  audience: 'both',
+  aiMetadata: { description: 'Lists objects in a bucket, optionally narrowed by name prefix, glob pattern, delimiter (for hierarchical/folder listing), or object versions; with no filters it returns all objects. Use to find files or enumerate bucket contents, and pass the returned page token to paginate. Idempotent read that does not modify storage. Requires the bucket name.', idempotent: true },
+  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,15 @@
+import { PieceAuth } from '@agnocon/pieces-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',
+    'email'
+  ],
+});

package/src/lib/common/client.ts

@@ -0,0 +1,63 @@
+import {
+  httpClient,
+  HttpMethod,
+  AuthenticationType,
+} from '@agnocon/pieces-common';
+import { OAuth2PropertyValue } from '@agnocon/pieces-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);
+  },
+};