@guayaba/workflow-piece-googlechat 0.1.3

package/src/lib/actions/get-direct-message-details.ts

@@ -0,0 +1,27 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import { propsValidation } from '@guayaba/workflows-common';
+import { googleChatApiAuth, googleChatCommon } from '../common';
+import { directMessagesDropdown, spacesDropdown } from '../common/props';
+import { googleChatAPIService } from '../common/requests';
+
+export const getDirectMessageDetails = createAction({
+  auth: googleChatApiAuth,
+  name: 'getDirectMessageDetails',
+  displayName: 'Get Direct Message Details',
+  description: 'Retrieve details of a specific direct message by ID.',
+  props: {
+    directMessageId: directMessagesDropdown({ refreshers: ['auth'], required: true }),
+  },
+  async run({ auth, propsValue }) {
+    await propsValidation.validateZod(propsValue, googleChatCommon.getDirectMessageDetailsSchema);
+
+    const { directMessageId } = propsValue;
+
+    const response = await googleChatAPIService.getSpace({
+      accessToken: auth.access_token,
+      spaceId: directMessageId as string,
+    });
+
+    return response;
+  },
+});

package/src/lib/actions/get-message.ts

@@ -0,0 +1,30 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import { propsValidation } from '@guayaba/workflows-common';
+import { googleChatApiAuth, googleChatCommon } from '../common';
+import { googleChatAPIService } from '../common/requests';
+
+export const getMessageDetails = createAction({
+  auth: googleChatApiAuth,
+  name: 'getMessageDetails',
+  displayName: 'Get Message Details',
+  description: 'Retrieve details of a specific message by ID. Supports both system-generated and custom message IDs.',
+  props: {
+    name: Property.ShortText({
+      displayName: 'Message Resource Name',
+      description: 'The full resource name of the message. Format: spaces/{space}/messages/{message}',
+      required: true,
+    }),
+  },
+  async run({ auth, propsValue }) {
+    await propsValidation.validateZod(propsValue, googleChatCommon.getMessageSchema);
+
+    const { name } = propsValue;
+
+    const message = await googleChatAPIService.getMessage(
+      auth.access_token,
+      name
+    );
+
+    return message;
+  },
+});

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

@@ -0,0 +1,45 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import { propsValidation } from '@guayaba/workflows-common';
+import { googleChatApiAuth, googleChatCommon } from '../common';
+import { allSpacesDropdown } from '../common/props';
+import { googleChatAPIService } from '../common/requests';
+
+export const searchMessages = createAction({
+  auth: googleChatApiAuth,
+  name: 'searchMessages',
+  displayName: 'Search Messages',
+  description: 'Search within Chat for messages matching keywords or filters.',
+  props: {
+    spaceId: allSpacesDropdown({ refreshers: ['auth'], required: true }),
+    keyword: Property.ShortText({
+      displayName: 'Keyword',
+      description: 'Search for messages containing this text',
+      required: true,
+    }),
+    limit: Property.Number({
+      displayName: 'Max Results',
+      description: 'Maximum number of messages to return',
+      required: false,
+      defaultValue: 50,
+    }),
+  },
+  async run({ auth, propsValue }) {
+    await propsValidation.validateZod(propsValue, googleChatCommon.searchMessagesSchema);
+
+    const { spaceId, keyword, limit } = propsValue;
+
+    const response = await googleChatAPIService.listMessages(
+      auth.access_token,
+      spaceId as string,
+      limit
+    );
+
+    const messages = response.messages || [];
+
+    const filtered = messages.filter((msg: any) =>
+      msg.text?.toLowerCase().includes(keyword.toLowerCase())
+    );
+
+    return filtered;
+  },
+});

package/src/lib/actions/send-a-message.ts

@@ -0,0 +1,110 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import { propsValidation } from '@guayaba/workflows-common';
+import { googleChatApiAuth, googleChatCommon } from '../common';
+import { allSpacesDropdown, spacesDropdown, peoplesDropdown, threadsDropdown } from '../common/props';
+import { googleChatAPIService } from '../common/requests';
+
+export const sendAMessage = createAction({
+  auth: googleChatApiAuth,
+  name: 'sendAMessage',
+  displayName: 'Send a Message',
+  description: 'Send a message to a space or direct conversation.',
+  props: {
+    spaceId: allSpacesDropdown({ refreshers: ['auth'], required: true }),
+    text: Property.LongText({
+      displayName: 'Message',
+      description: 'The message content to send. Supports basic formatting like *bold*, _italic_, and @mentions.',
+      required: true,
+    }),
+    thread: threadsDropdown({ refreshers: ['auth', 'spaceId'], required: false }),
+    messageReplyOption: Property.StaticDropdown({
+      displayName: 'Reply Behavior',
+      description: 'How to handle replies when thread ID is provided.',
+      required: false,
+      options: {
+        options: [
+          {
+            label: 'Reply or start new thread',
+            value: 'REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD',
+          },
+          {
+            label: 'Reply only (fail if thread not found)',
+            value: 'REPLY_MESSAGE_OR_FAIL',
+          },
+        ],
+      },
+    }),
+    customMessageId: Property.ShortText({
+      displayName: 'Custom Message ID',
+      description: 'Optional unique ID for this message (auto-generated if empty). Useful for deduplication.',
+      required: false,
+    }),
+    isPrivate: Property.Checkbox({
+      displayName: 'Send as Private Message',
+      description: 'Send this message privately to a specific user. Requires app authentication.',
+      required: false,
+    }),
+    privateMessageViewer: Property.Dropdown({
+      displayName: 'Private Message Recipient',
+      description: 'Select the user who can view this private message.',
+      required: false,
+      refreshers: ['auth'],
+      auth: googleChatApiAuth,
+      async options({ auth }) {
+        if (!auth) {
+          return {
+            disabled: true,
+            placeholder: 'Connect your Google account first',
+            options: [],
+          };
+        }
+
+        try {
+          const members = await googleChatAPIService.fetchPeople(
+            auth.access_token
+          );
+
+          return {
+            options: members
+              .map((member: any) => {
+                const nameObj =
+                  member.names?.find((n: any) => n.metadata.primary) ||
+                  member.names?.[0];
+                if (!nameObj) return null;
+
+                return {
+                  label: nameObj.displayName,
+                  value: member.resourceName,
+                };
+              })
+              .filter(Boolean),
+          };
+        } catch (e) {
+          console.error('Failed to fetch people', e);
+          return {
+            options: [],
+            placeholder: 'Unable to load people',
+          };
+        }
+      },
+    }),
+  },
+  async run({ auth, propsValue }) {
+    await propsValidation.validateZod(propsValue, googleChatCommon.sendMessageSchema);
+
+    const { spaceId, text, thread, messageReplyOption, customMessageId, isPrivate, privateMessageViewer } = propsValue;
+
+    const response = await googleChatAPIService.sendMessage({
+      accessToken: auth.access_token,
+      spaceId: spaceId as string,
+      text,
+      thread,
+      messageReplyOption,
+      customMessageId,
+      isPrivate,
+      privateMessageViewer,
+    });
+
+    return response;
+  },
+});

package/src/lib/common/constants.ts

@@ -0,0 +1,22 @@
+import { PieceAuth } from "@guayaba/workflows-framework";
+
+export const googleChatApiAuth = PieceAuth.OAuth2({
+  authUrl: 'https://accounts.google.com/o/oauth2/auth',
+  tokenUrl: 'https://oauth2.googleapis.com/token',
+  required: true,
+  scope: [
+    'https://www.googleapis.com/auth/chat.messages',
+    'https://www.googleapis.com/auth/chat.spaces',
+    'https://www.googleapis.com/auth/chat.memberships',
+    'https://www.googleapis.com/auth/cloud-platform',
+    'https://www.googleapis.com/auth/directory.readonly',
+  ],
+});
+
+export const GOOGLE_SERVICE_ENTITIES = {
+  chat: 'chat',
+  cloudresourcemanager: 'cloudresourcemanager',
+  pubsub: 'pubsub',
+  workspaceevents: 'workspaceevents',
+  people: 'people',
+};

package/src/lib/common/index.ts

@@ -0,0 +1,17 @@
+export * from './schemas';
+export * from './constants';
+export * from './props';
+export * from './requests';
+
+import * as schemas from './schemas';
+
+export const googleChatCommon = {
+  sendMessageSchema: schemas.sendMessageSchema,
+  getMessageSchema: schemas.getMessageSchema,
+  addSpaceMemberSchema: schemas.addSpaceMemberSchema,
+  findMemberSchema: schemas.findMemberSchema,
+  searchMessagesSchema: schemas.searchMessagesSchema,
+  getDirectMessageDetailsSchema: schemas.getDirectMessageDetailsSchema,
+  newMessageTriggerSchema: schemas.newMessageTriggerSchema,
+  newMentionTriggerSchema: schemas.newMentionTriggerSchema,
+};

package/src/lib/common/props.ts

@@ -0,0 +1,332 @@
+import { Property } from '@guayaba/workflows-framework';
+import { googleChatAPIService } from './requests';
+import { googleChatApiAuth } from './constants';
+
+export const projectsDropdown = (refreshers: string[]) =>
+  Property.Dropdown({
+    displayName: 'Project',
+    description: 'Select a Google Cloud Project',
+    required: true,
+    refreshers,
+    auth: googleChatApiAuth,
+    async options({ auth }: any) {
+      if (!auth) {
+        return {
+          disabled: true,
+          placeholder: 'Connect your Google account first',
+          options: [],
+        };
+      }
+
+      try {
+        const projects = await googleChatAPIService.fetchProjects(
+          auth.access_token
+        );
+
+        return {
+          options: projects.map((project: any) => ({
+            label: project.name,
+            value: project.projectId,
+          })),
+        };
+      } catch (e) {
+        console.error('Failed to fetch projects', e);
+        return {
+          options: [],
+          placeholder: 'Unable to load projects',
+        };
+      }
+    },
+  });
+
+export const spacesDropdown = ({
+  refreshers,
+  required = false,
+}: {
+  refreshers: string[];
+  required?: boolean;
+}) =>
+  Property.Dropdown({
+    auth: googleChatApiAuth,
+    displayName: 'Space',
+    description: `Select a Space${
+      required ? '' : ', leave empty for all spaces'
+    }`,
+    required,
+    refreshers,
+    async options({ auth }: any) {
+      if (!auth) {
+        return {
+          disabled: true,
+          placeholder: 'Connect your Google account first',
+          options: [],
+        };
+      }
+
+      try {
+        const spaces = await googleChatAPIService.fetchSpaces(
+          auth.access_token
+        );
+
+        return {
+          options: spaces.map((space: any) => ({
+            label: space.displayName || space.name,
+            value: space.name,
+          })),
+        };
+      } catch (e) {
+        console.error('Failed to fetch spaces', e);
+        return {
+          options: [],
+          placeholder: 'Unable to load spaces',
+        };
+      }
+    },
+  });
+
+export const allSpacesDropdown = ({
+  refreshers,
+  required = false,
+}: {
+  refreshers: string[];
+  required?: boolean;
+}) =>
+  Property.Dropdown({
+    auth: googleChatApiAuth,
+    displayName: 'Space',
+    description: `Select a Space${
+      required ? '' : ', leave empty for all spaces'
+    }`,
+    required,
+    refreshers,
+    async options({ auth }: any) {
+      if (!auth) {
+        return {
+          disabled: true,
+          placeholder: 'Connect your Google account first',
+          options: [],
+        };
+      }
+
+      try {
+        const spaces = await googleChatAPIService.fetchAllSpaces(
+          auth.access_token
+        );
+
+        return {
+          options: spaces.map((space: any) => ({
+            label: space.displayName || space.name,
+            value: space.name,
+          })),
+        };
+      } catch (e) {
+        console.error('Failed to fetch spaces', e);
+        return {
+          options: [],
+          placeholder: 'Unable to load spaces',
+        };
+      }
+    },
+  });
+
+export const directMessagesDropdown = ({
+  refreshers,
+  required = false,
+}: {
+  refreshers: string[];
+  required?: boolean;
+}) =>
+  Property.Dropdown({
+    auth: googleChatApiAuth,
+    displayName: 'Direct Message',
+    description: `Select a Direct Message${
+      required ? '' : ', leave empty for all spaces'
+    }`,
+    required,
+    refreshers,
+    async options({ auth }: any) {
+      if (!auth) {
+        return {
+          disabled: true,
+          placeholder: 'Connect your Google account first',
+          options: [],
+        };
+      }
+
+      try {
+        const spaces = await googleChatAPIService.fetchDirectMessages(
+          auth.access_token
+        );
+
+        return {
+          options: spaces.map((space: any) => ({
+            label: space.displayName || space.name,
+            value: space.name,
+          })),
+        };
+      } catch (e) {
+        console.error('Failed to fetch spaces', e);
+        return {
+          options: [],
+          placeholder: 'Unable to load spaces',
+        };
+      }
+    },
+  });
+
+export const spacesMembersDropdown = (refreshers: string[]) =>
+  Property.Dropdown({
+    auth: googleChatApiAuth,
+    displayName: 'Space Member',
+    description: 'Select a space member, leave empty for all members',
+    required: false,
+    refreshers,
+    async options({ auth, spaceId }) {
+      if (!auth) {
+        return {
+          disabled: true,
+          placeholder: 'Connect your Google account first',
+          options: [],
+        };
+      }
+
+      if (!spaceId || typeof spaceId !== 'string') {
+        return {
+          disabled: true,
+          placeholder: 'Please select a space first',
+          options: [],
+        };
+      }
+
+      try {
+        const members = await googleChatAPIService.fetchSpaceMembers(
+          auth.access_token,
+          spaceId
+        );
+
+        return {
+          options: members.map((member: any) => ({
+            label: member.member.name,
+            value: member.member.name,
+          })),
+        };
+      } catch (e) {
+        console.error('Failed to fetch space members', e);
+        return {
+          options: [],
+          placeholder: 'Unable to load space members',
+        };
+      }
+    },
+  });
+
+export const peoplesDropdown = (refreshers: string[]) =>
+  Property.Dropdown({
+    auth: googleChatApiAuth,
+    displayName: 'Select A Person',
+    description: 'Select a person',
+    required: true,
+    refreshers,
+    async options({ auth }) {
+      if (!auth) {
+        return {
+          disabled: true,
+          placeholder: 'Connect your Google account first',
+          options: [],
+        };
+      }
+
+      try {
+        const members = await googleChatAPIService.fetchPeople(
+          auth.access_token
+        );
+
+        return {
+          options: members
+            .map((member: any) => {
+              const nameObj =
+                member.names?.find((n: any) => n.metadata.primary) ||
+                member.names?.[0];
+              if (!nameObj) return null;
+
+              return {
+                label: nameObj.displayName,
+                value: member.resourceName,
+              };
+            })
+            .filter(Boolean),
+        };
+      } catch (e) {
+        console.error('Failed to fetch people', e);
+        return {
+          options: [],
+          placeholder: 'Unable to load people',
+        };
+      }
+    },
+  });
+
+export const threadsDropdown = ({
+  refreshers,
+  required = false,
+}: {
+  refreshers: string[];
+  required?: boolean;
+}) =>
+  Property.Dropdown({
+    auth: googleChatApiAuth,
+    displayName: 'Thread',
+    description: `Select a thread to reply to${required ? '' : ', leave empty for new thread'}`,
+    required,
+    refreshers,
+    async options({ auth, spaceId }) {
+      if (!auth) {
+        return {
+          disabled: true,
+          placeholder: 'Connect your Google account first',
+          options: [],
+        };
+      }
+
+      if (!spaceId || typeof spaceId !== 'string') {
+        return {
+          disabled: true,
+          placeholder: 'Please select a space first',
+          options: [],
+        };
+      }
+
+      if (!spaceId.startsWith('spaces/')) {
+        return {
+          disabled: true,
+          placeholder: 'Invalid space ID format. Please select a valid space.',
+          options: [],
+        };
+      }
+
+      try {
+        const threads = await googleChatAPIService.fetchThreads(
+          auth.access_token,
+          spaceId
+        );
+
+        const options = threads.map((thread: any) => ({
+          label: thread.displayName || thread.name,
+          value: thread.name,
+        }));
+
+        options.unshift({
+          label: 'Start new thread',
+          value: '',
+        });
+
+        return { options };
+      } catch (e) {
+        console.error('Failed to fetch threads', e);
+        return {
+          options: [],
+          placeholder: 'Unable to load threads',
+        };
+      }
+    },
+  });