[pull] master from botpress:master

integrations/linear/integration.definition.ts

@@ -6,7 +6,7 @@ import { actions, channels, events, configuration, configurations, user, states,
 
 export default new IntegrationDefinition({
   name: 'linear',
-  version: '1.1.5',
+  version: '1.2.0',
   title: 'Linear',
   description:
     'Manage your projects autonomously. Have your bot participate in discussions, manage issues and teams, and track progress.',

integrations/linear/package.json

@@ -10,7 +10,7 @@
     "@botpress/client": "workspace:*",
     "@botpress/sdk": "workspace:*",
     "@botpress/sdk-addons": "workspace:*",
-    "@linear/sdk": "^2.6.0",
+    "@linear/sdk": "^65.2.0",
     "axios": "^1.4.0",
     "query-string": "^6.14.1",
     "tsafe": "^1.6.4"

integrations/linear/src/handler.ts

@@ -1,5 +1,5 @@
 import { Request } from '@botpress/sdk'
-import { LinearWebhooks, LINEAR_WEBHOOK_SIGNATURE_HEADER, LINEAR_WEBHOOK_TS_FIELD } from '@linear/sdk'
+import { LinearWebhooks } from '@linear/sdk'
 
 import { fireIssueCreated } from './events/issueCreated'
 import { fireIssueDeleted } from './events/issueDeleted'
@@ -9,6 +9,9 @@ import { Result } from './misc/types'
 import { getLinearClient, getUserAndConversation } from './misc/utils'
 import * as bp from '.botpress'
 
+const LINEAR_WEBHOOK_SIGNATURE_HEADER = 'linear-signature'
+const LINEAR_WEBHOOK_TS_FIELD = 'webhookTimestamp'
+
 export const handler: bp.IntegrationProps['handler'] = async ({ req, ctx, client, logger }) => {
   if (req.path === '/oauth') {
     return handleOauth(req, client, ctx).catch((err) => {

integrations/linear/src/misc/utils.ts

@@ -1,4 +1,4 @@
-import { Comment, Issue, IssueLabel, LinearClient, Team } from '@linear/sdk'
+import { Issue, LinearClient, Team } from '@linear/sdk'
 import { LinearOauthClient } from './linear'
 import { AckFunction, MessageHandlerProps } from './types'
 import * as bp from '.botpress'
@@ -12,50 +12,6 @@ export function getLinearClient({ client, ctx }: LinearClientProps, integrationI
   return linearOauthClient.getLinearClient(client, ctx, integrationId)
 }
 
-export function dateToString(obj: Date | undefined) {
-  return obj ? obj.toISOString() : undefined
-}
-
-export function stringToDate(str: string | undefined) {
-  return str ? new Date(str) : undefined
-}
-
-export function toReturnedIssue(issue: Issue) {
-  return {
-    ...issue,
-    createdAt: issue.createdAt.toISOString(),
-    updatedAt: issue.updatedAt.toISOString(),
-    archivedAt: dateToString(issue.archivedAt),
-    canceledAt: dateToString(issue.canceledAt),
-    completedAt: dateToString(issue.completedAt),
-    autoArchivedAt: dateToString(issue.autoArchivedAt),
-    autoClosedAt: dateToString(issue.autoClosedAt),
-    snoozedUntilAt: dateToString(issue.snoozedUntilAt),
-    startedAt: dateToString(issue.startedAt),
-    startedTriageAt: dateToString(issue.startedTriageAt),
-    triagedAt: dateToString(issue.triagedAt),
-  }
-}
-
-export function toReturnedComment(comment: Comment) {
-  return {
-    ...comment,
-    archivedAt: dateToString(comment.archivedAt),
-    editedAt: dateToString(comment.editedAt),
-    createdAt: comment.createdAt.toISOString(),
-    updatedAt: comment.updatedAt.toISOString(),
-  }
-}
-
-export function toReturnedIssueLabel(issueLabel: IssueLabel) {
-  return {
-    ...issueLabel,
-    archivedAt: dateToString(issueLabel.archivedAt),
-    createdAt: issueLabel.createdAt.toISOString(),
-    updatedAt: issueLabel.updatedAt.toISOString(),
-  }
-}
-
 type ValueOf<T> = T[keyof T]
 type CreateCommentProps = Omit<ValueOf<bp.MessageProps['issue']>, 'payload'> & { content: string }
 export async function createComment(args: CreateCommentProps) {

packages/common/src/posthog/helper.ts

@@ -15,6 +15,13 @@ export type PostHogConfig = {
   integrationVersion: string
 }
 
+type WrapFunctionProps = {
+  config: PostHogConfig
+  fn: Function
+  functionName: string
+  functionArea: string
+}
+
 export const sendPosthogEvent = async (props: EventMessage, config: PostHogConfig): Promise<void> => {
   const { key, integrationName, integrationVersion } = config
   const client = new PostHog(key, {
@@ -39,15 +46,35 @@ export const sendPosthogEvent = async (props: EventMessage, config: PostHogConfi
 }
 
 export function wrapIntegration(config: PostHogConfig, integrationProps: sdk.IntegrationProps<any>) {
-  integrationProps.register = wrapFunction(integrationProps.register, config, 'register')
-  integrationProps.unregister = wrapFunction(integrationProps.unregister, config, 'unregister')
-  integrationProps.handler = wrapFunction(wrapHandler(integrationProps.handler, config), config, 'handler')
+  integrationProps.register = wrapFunction({
+    fn: integrationProps.register,
+    config,
+    functionName: 'register',
+    functionArea: 'registration',
+  })
+  integrationProps.unregister = wrapFunction({
+    fn: integrationProps.unregister,
+    config,
+    functionName: 'unregister',
+    functionArea: 'registration',
+  })
+  integrationProps.handler = wrapFunction({
+    fn: wrapHandler(integrationProps.handler, config),
+    config,
+    functionName: 'handler',
+    functionArea: 'handler',
+  })
 
   if (integrationProps.actions) {
     for (const actionType of Object.keys(integrationProps.actions)) {
       const actionFn = integrationProps.actions[actionType]
       if (typeof actionFn === 'function') {
-        integrationProps.actions[actionType] = wrapFunction(actionFn, config, actionType)
+        integrationProps.actions[actionType] = wrapFunction({
+          fn: actionFn,
+          config,
+          functionName: actionType,
+          functionArea: 'actions',
+        })
       }
     }
   }
@@ -59,18 +86,24 @@ export function wrapIntegration(config: PostHogConfig, integrationProps: sdk.Int
       Object.keys(channel.messages).forEach((messageType) => {
         const messageFn = channel.messages[messageType]
         if (typeof messageFn === 'function') {
-          channel.messages[messageType] = wrapFunction(messageFn, config, channelName)
+          channel.messages[messageType] = wrapFunction({
+            fn: messageFn,
+            config,
+            functionName: channelName,
+            functionArea: 'channels',
+          })
         }
       })
     }
   }
   return new sdk.Integration(integrationProps)
 }
 
-function wrapFunction(fn: Function, config: PostHogConfig, functionName: string) {
+function wrapFunction(props: WrapFunctionProps) {
+  const { config, fn, functionArea, functionName } = props
   return async (...args: any[]) => {
     try {
-      return await fn(...args)
+      fn(...args)
     } catch (thrown) {
       const errMsg = thrown instanceof Error ? thrown.message : String(thrown)
       const distinctId = client.isApiError(thrown) ? thrown.id : undefined
@@ -85,6 +118,7 @@ function wrapFunction(fn: Function, config: PostHogConfig, functionName: string)
           event: 'unhandled_error',
           properties: {
             from: functionName,
+            area: functionArea,
             integrationName: config.integrationName,
             integrationVersion: config.integrationVersion,
             errMsg,