Fix refresh connection not working, address feedback

Author: Rodri77

apps/web/public/_assets/logo-greenhouse2.svg

@@ -728,9 +728,7 @@ export default {
       displayName: 'Greenhouse 2',
       stage: 'alpha',
       verticals: ['ats'],
-      // TODO: Review why this is not working, asset exists in _assets folder
-      // Is this used? connector is trying to get _assets/logo-greenhouse2.svg
-      logoUrl: '/_assets/logo-greenhouse.svg',
+      logoUrl: '/_assets/logo-greenhouse2.svg',
       authType: 'API_KEY',
     },
   },

connectors/all-connectors/connectors.meta.ts

@@ -1,3 +1,4 @@
+import type {ConnectorDef} from '@openint/cdk'
 import type {Z} from '@openint/util/zod-utils'
 import type {JsonConnectorDef} from '../schema'
 
@@ -9,51 +10,59 @@ export function createApiKeyConnectorDef<
   T extends JsonConnectorDef,
 >(name: N, def: T) {
   const connectorConfig = () => {
-    let schema = apiKeySchemas.connector_config
+    let schema = apiKeySchemas.connector_config.unwrap().unwrap()
     if (Object.keys(def.auth?.connector_config ?? {}).length > 0) {
       // TODO: test this merge with other api key connectors
       schema = z.object({
         ...schema.shape,
-        ...(def.auth.connector_config.shape as Record<string, Z.ZodTypeAny>),
+        ...(def?.auth?.connector_config?.shape as Record<string, Z.ZodTypeAny>),
       })
     }
 
     return z.object({
-      ...(def.auth.connector_config?.shape as Record<string, Z.ZodTypeAny>),
+      ...(def?.auth?.connector_config?.shape as Record<string, Z.ZodTypeAny>),
     })
   }
 
   const connectionSettings = () => {
     const schema = apiKeySchemas.connection_settings
-    if (def.auth.connection_settings) {
+    if (schema) {
       return z
         .object({
-          ...(def.auth.connection_settings.shape as Record<
+          ...schema.shape,
+          ...(def.auth.connection_settings?.shape as Record<
             string,
             Z.ZodTypeAny
           >),
         })
         .openapi({effectType: 'input'})
     }
-    return schema
+    return z
+      .object({
+        ...(def.auth.connection_settings?.shape as Record<
+          string,
+          Z.ZodTypeAny
+        >),
+      })
+      .openapi({effectType: 'input'})
   }
 
   return {
     name,
     schemas: {
       ...apiKeySchemas,
       name: z.literal(name),
-      connector_config: connectorConfig(),
-      connection_settings: connectionSettings(),
+      connector_config: connectorConfig() as any,
+      connection_settings: connectionSettings() as any,
     },
     metadata: {
       displayName: def.display_name,
       stage: def.stage,
       verticals: def.verticals,
       // TODO: We should get this from the connector def/meta
       logoUrl: `/_assets/logo-${name}.svg`,
-      authType: def.auth.type,
+      authType: def?.auth?.type,
       jsonDef: def,
     },
-  }
+  } satisfies ConnectorDef<typeof apiKeySchemas & {name: Z.ZodLiteral<N>}>
 }

connectors/cnext/auth-apikey/createApiKeyConnectorDef.ts

@@ -1,51 +1,68 @@
 import type {ConnectorDef, ConnectorServer} from '@openint/cdk'
 import type {Z} from '@openint/util/zod-utils'
-import type {apiKeySchemas, zApiKeyConfig} from './schemas'
-
-import {getClient} from './utils'
+import type {apiKeySchemas} from './schemas'
 
 export function createAPIKeyConnectorServer<
   TName extends string,
   T extends typeof apiKeySchemas & {name: Z.ZodLiteral<TName>},
->(
-  connectorDef: ConnectorDef<T>,
-  oauthConfigTemplate: Z.infer<typeof zApiKeyConfig>,
-): ConnectorServer<T, ReturnType<typeof getClient>> {
+>(connectorDef: ConnectorDef<T>): ConnectorServer<T> {
   if (connectorDef.metadata?.authType !== 'API_KEY') {
     throw new Error('This server can only be used with API Key connectors')
   }
 
   const baseServer = {
-    newInstance: ({config, settings, context}) => {
-      return getClient({
-        connectorName: connectorDef.name,
-        oauthConfigTemplate,
-        connectorConfig: config,
-        connectionSettings: settings,
-        fetch: context.fetch,
-        baseURLs: context.baseURLs,
-      })
-    },
+    async checkConnection({settings}) {
+      const auth = connectorDef.metadata?.jsonDef?.auth
+
+      if (!auth || auth.type !== 'API_KEY') {
+        throw new Error('Invalid connector definition')
+      }
+
+      const url = `${auth?.base_url}${auth?.verification.endpoint}`
+
+      const apiKey = settings?.api_key
+      if (!apiKey) {
+        throw new Error('Credentials are not configured')
+      }
+
+      // Handle Basic auth by base64 encoding the API key
+      const authHeader =
+        auth?.verification.header_mode === 'Basic'
+          ? `Basic ${Buffer.from(`${apiKey}:`).toString('base64').trim()}`
+          : `${auth?.verification.header_mode} ${apiKey}`
 
-    // TODO: Review why we get a type error here but this param works fine
-    //  in the oauth2 connector
-    async checkConnection({instance}) {
-      const {client} = instance
       try {
-        await client.GET('/v1/jobs')
-        return {status: 'healthy'}
-      } catch (err) {
-        console.warn('Greenhouse checkConnection error', err)
+        const response = await fetch(url, {
+          method: auth?.verification.method,
+          headers: {
+            Authorization: authHeader,
+          },
+        })
+
+        if (!response.ok) {
+          const errorText = await response
+            .text()
+            .catch(() => 'No error details available')
+          throw new Error(
+            `Connection check failed with status ${response.status} (${response.statusText}): ${errorText}`,
+          )
+        }
+
+        return {
+          status: 'healthy',
+          status_message: null,
+          settings,
+        }
+      } catch (error) {
         return {
           status: 'disconnected',
-          status_message: `Failed to connect to Greenhouse: ${err}`,
+          status_message:
+            error instanceof Error ? error.message : String(error),
+          settings,
         }
       }
     },
-  } satisfies ConnectorServer<T, ReturnType<typeof getClient>>
+  } satisfies ConnectorServer<typeof apiKeySchemas & {name: T['name']}>
 
-  return baseServer as unknown as ConnectorServer<
-    ConnectorDef<T>['schemas'],
-    ReturnType<typeof getClient>
-  >
+  return baseServer as unknown as ConnectorServer<ConnectorDef<T>['schemas']>
 }

connectors/cnext/auth-apikey/createApiKeyConnectorServer.ts

@@ -4,14 +4,16 @@ export const zAPIKeyConnectorDef = z.object({
   type: z
     .literal('API_KEY')
     .describe('The authentication type for API Key-based providers'),
-  api_key_field: z
-    .string()
-    .describe('Field name where the API key should be passed'),
-  api_key_location: z
-    .enum(['header', 'query'])
-    .describe(
-      'Specifies whether the API key is passed in headers or query parameters',
-    ),
+  base_url: z.string().url().describe('The base URL of the API'),
+  verification: z.object({
+    method: z
+      .enum(['GET', 'POST'])
+      .describe('The method to verify the API key'),
+    header_mode: z
+      .enum(['Basic', 'Bearer'])
+      .describe('The header to verify the API key'),
+    endpoint: z.string().describe('The endpoint to verify the API key'),
+  }),
   connector_config: z
     .object({})
     .optional()
@@ -20,7 +22,6 @@ export const zAPIKeyConnectorDef = z.object({
   connection_settings: z
     .object({})
     .optional()
-    .default({})
     .describe('Additional configuration for api key connection settings'),
   overrides: z
     .object({

connectors/cnext/auth-apikey/def.ts

@@ -5,28 +5,17 @@ import {z} from '@openint/util/zod-utils'
 
 const zApiKeyConnectorConfig = z
   .object({})
-  .describe('Base oauth configuration for api key connector')
+  .describe('Base api key configuration for api key connector')
 
 const zApiKeyConnectionSettings = z.object({
-  credentials: z
-    .object({
-      api_key: z.string(),
-    })
-    .optional()
-    .describe('Output of the postConnect hook for oauth2 connectors'),
+  api_key: z.string(),
 })
 
 export type ApiKeyConnectorConfig = Z.infer<typeof zApiKeyConnectorConfig>
 
 export const apiKeySchemas = {
-  connector_config: z.object({
-    oauth: zApiKeyConnectorConfig.nullish(),
-  }),
-  connection_settings: z
-    .object({
-      oauth: zApiKeyConnectionSettings,
-    })
-    .openapi({effectType: 'input'}),
+  connector_config: zApiKeyConnectorConfig.nullish(),
+  connection_settings: zApiKeyConnectionSettings.openapi({effectType: 'input'}),
   pre_connect_input: z.object({}),
   connect_input: z.object({}),
   connect_output: z.object({

connectors/cnext/auth-apikey/schemas.ts

@@ -22,7 +22,7 @@ export function createOAuth2ConnectorDef<
       // TODO: does this need to do a deep merge of connectorConfig.oauth keys?
       schema = z.object({
         ...schema.shape,
-        ...(def.auth.connector_config.shape as Record<string, Z.ZodTypeAny>),
+        ...(def.auth?.connector_config?.shape as Record<string, Z.ZodTypeAny>),
       })
     }
 
@@ -33,8 +33,9 @@ export function createOAuth2ConnectorDef<
     if (defaultCredentialsConfigured) {
       // Only use default_scopes if they exist, otherwise use an empty array
       const openintDefaultCredentialsScopes =
-        def.auth.type === 'OAUTH2'
-          ? (def.auth.openint_allowed_scopes ?? def.auth.openint_default_scopes)
+        def.auth?.type === 'OAUTH2'
+          ? (def.auth?.openint_allowed_scopes ??
+            def.auth?.openint_default_scopes)
           : []
       const zOpenIntDefaultScopes = z.array(
         z.enum(openintDefaultCredentialsScopes as [string, ...string[]]),
@@ -70,18 +71,18 @@ export function createOAuth2ConnectorDef<
     return z.object({
       oauth: schema.shape.oauth,
       // make sure to merge in any additional connector config fields
-      ...(def.auth.connector_config?.shape as Record<string, Z.ZodTypeAny>),
+      ...(def.auth?.connector_config?.shape as Record<string, Z.ZodTypeAny>),
     })
   }
 
   const connectionSettings = () => {
     const schema = oauth2Schemas.connection_settings
-    if (def.auth.connection_settings) {
+    if (def.auth?.connection_settings) {
       return (
         z
           .object({
             ...schema.innerType().shape,
-            ...(def.auth.connection_settings.shape as Record<
+            ...(def.auth?.connection_settings?.shape as Record<
               string,
               Z.ZodTypeAny
             >),
@@ -112,7 +113,7 @@ export function createOAuth2ConnectorDef<
       stage: def.stage,
       verticals: def.verticals,
       logoUrl: `/_assets/logo-${name}.svg`,
-      authType: def.auth.type,
+      authType: def.auth?.type,
       jsonDef: def,
     },
   } satisfies ConnectorDef<typeof oauth2Schemas & {name: Z.ZodLiteral<N>}>

connectors/cnext/auth-apikey/utils.ts

@@ -14,7 +14,7 @@ const getConnectorDefFnByAuthMode = (
     case 'API_KEY':
       return createApiKeyConnectorDef
     default:
-      return createOAuth2ConnectorDef
+      throw new Error('Unsupported connector auth type')
   }
 }