@yolk-sdk/connectors 0.0.1-canary.0

package/src/connector.ts

@@ -0,0 +1,62 @@
+import { Effect, Option } from 'effect'
+import type { ConnectorAction } from './action.ts'
+import { ConnectorError } from './error.ts'
+import type { ActionResult } from './result.ts'
+import type { ConnectorIntegration } from './integration.ts'
+
+export type ConnectorInvokeInput = {
+  readonly integration: ConnectorIntegration
+  readonly action: string
+  readonly input: unknown
+}
+
+export type Connector<Env = never, Error = never> = {
+  readonly id: string
+  readonly description?: string
+  readonly actions: ReadonlyArray<ConnectorAction<Env, Error>>
+  readonly invoke: (
+    input: ConnectorInvokeInput
+  ) => Effect.Effect<ActionResult<unknown>, Error | ConnectorError, Env>
+}
+
+export type DefineConnectorOptions<Env, Error> = {
+  readonly id: string
+  readonly description?: string
+  readonly actions: ReadonlyArray<ConnectorAction<Env, Error>>
+}
+
+const connectorMismatchError = (connectorId: string, integration: ConnectorIntegration) =>
+  new ConnectorError({
+    cause: 'connector_mismatch',
+    message: `Integration belongs to ${integration.connectorId}, not ${connectorId}`,
+    connectorId
+  })
+
+const missingActionError = (connectorId: string, actionId: string) =>
+  new ConnectorError({
+    cause: 'action_not_found',
+    message: `Connector action is not configured: ${actionId}`,
+    connectorId,
+    actionId
+  })
+
+export const defineConnector = <Env = never, Error = never>(
+  options: DefineConnectorOptions<Env, Error>
+): Connector<Env, Error> => ({
+  id: options.id,
+  description: options.description,
+  actions: options.actions,
+  invoke: input => {
+    if (input.integration.connectorId !== options.id) {
+      return Effect.fail(connectorMismatchError(options.id, input.integration))
+    }
+
+    const action = Option.fromNullishOr(options.actions.find(item => item.id === input.action))
+
+    if (Option.isNone(action)) {
+      return Effect.fail(missingActionError(options.id, input.action))
+    }
+
+    return action.value.execute({ integration: input.integration, input: input.input })
+  }
+})

package/src/credential.ts

@@ -0,0 +1,86 @@
+import { Context, Effect, Option } from 'effect'
+import * as Schema from 'effect/Schema'
+import { ConnectorError } from './error.ts'
+import type { ConnectorIntegration } from './integration.ts'
+
+export const CredentialKind = Schema.Literals(['api_key', 'bearer_token', 'oauth'])
+export type CredentialKind = typeof CredentialKind.Type
+
+export class CredentialSlot extends Schema.Class<CredentialSlot>('CredentialSlot')({
+  id: Schema.String,
+  kind: CredentialKind,
+  requiredScopes: Schema.optional(Schema.Array(Schema.String))
+}) {}
+
+export class CredentialBinding extends Schema.Class<CredentialBinding>('CredentialBinding')({
+  slotId: Schema.String,
+  credentialRef: Schema.String,
+  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown))
+}) {}
+
+export class ApiKeyCredential extends Schema.Class<ApiKeyCredential>('ApiKeyCredential')({
+  _tag: Schema.Literal('ApiKeyCredential'),
+  key: Schema.String
+}) {}
+
+export class BearerTokenCredential extends Schema.Class<BearerTokenCredential>('BearerTokenCredential')({
+  _tag: Schema.Literal('BearerTokenCredential'),
+  token: Schema.String,
+  expiresAt: Schema.optional(Schema.Number)
+}) {}
+
+export class OAuthCredential extends Schema.Class<OAuthCredential>('OAuthCredential')({
+  _tag: Schema.Literal('OAuthCredential'),
+  provider: Schema.String,
+  accessToken: Schema.String,
+  expiresAt: Schema.Number,
+  accountId: Schema.optional(Schema.String),
+  scopes: Schema.optional(Schema.Array(Schema.String))
+}) {}
+
+export const RuntimeCredential = Schema.Union([ApiKeyCredential, BearerTokenCredential, OAuthCredential])
+export type RuntimeCredential = typeof RuntimeCredential.Type
+
+export type CredentialResolveRequest = {
+  readonly integration: ConnectorIntegration
+  readonly slot: CredentialSlot
+  readonly binding: CredentialBinding
+}
+
+export type CredentialResolverApi = {
+  readonly resolve: (
+    request: CredentialResolveRequest
+  ) => Effect.Effect<RuntimeCredential, ConnectorError>
+}
+
+export class CredentialResolver extends Context.Service<CredentialResolver, CredentialResolverApi>()(
+  '@yolk-sdk/connectors/CredentialResolver'
+) {}
+
+export const makeCredentialBinding = (input: {
+  readonly slotId: string
+  readonly credentialRef: string
+  readonly metadata?: Readonly<Record<string, unknown>>
+}) => CredentialBinding.make(input)
+
+export const findCredentialBinding = (integration: ConnectorIntegration, slot: CredentialSlot) =>
+  Option.fromNullishOr(integration.credentialBindings.find(binding => binding.slotId === slot.id))
+
+export const resolveCredential = (integration: ConnectorIntegration, slot: CredentialSlot) =>
+  Effect.gen(function* () {
+    const binding = findCredentialBinding(integration, slot)
+
+    if (Option.isNone(binding)) {
+      return yield* Effect.fail(
+        new ConnectorError({
+          cause: 'credential_binding_missing',
+          message: `Missing credential binding for slot: ${slot.id}`,
+          connectorId: integration.connectorId,
+          slotId: slot.id
+        })
+      )
+    }
+
+    const resolver = yield* CredentialResolver
+    return yield* resolver.resolve({ integration, slot, binding: binding.value })
+  })

package/src/error.ts

@@ -0,0 +1,20 @@
+import * as Schema from 'effect/Schema'
+
+export const ConnectorErrorCause = Schema.Literals([
+  'action_not_found',
+  'connector_mismatch',
+  'credential_binding_missing',
+  'credential_invalid',
+  'credential_missing',
+  'validation_failed'
+])
+export type ConnectorErrorCause = typeof ConnectorErrorCause.Type
+
+export class ConnectorError extends Schema.TaggedErrorClass<ConnectorError>()('ConnectorError', {
+  cause: ConnectorErrorCause,
+  message: Schema.String,
+  connectorId: Schema.optional(Schema.String),
+  actionId: Schema.optional(Schema.String),
+  slotId: Schema.optional(Schema.String),
+  underlying: Schema.optional(Schema.Unknown)
+}) {}

package/src/figma/index.ts

@@ -0,0 +1,121 @@
+import { Effect } from 'effect'
+import * as Schema from 'effect/Schema'
+import { defineAction } from '../action.ts'
+import { optionalStringConfig } from '../config.ts'
+import { defineConnector } from '../connector.ts'
+import { CredentialSlot, resolveCredential } from '../credential.ts'
+import { ConnectorError } from '../error.ts'
+import { ActionResult } from '../result.ts'
+import type { ConnectorIntegration } from '../integration.ts'
+
+export const figmaConnectorId = 'figma'
+export const figmaOAuthSlotId = 'figma.oauth'
+export const figmaMcpServerUrl = 'https://mcp.figma.com/mcp'
+export const figmaOAuthRegisterUrl = 'https://api.figma.com/v1/oauth/mcp/register'
+export const figmaOAuthAuthorizeUrl = 'https://www.figma.com/oauth/mcp'
+export const figmaOAuthTokenUrl = 'https://api.figma.com/v1/oauth/token'
+export const figmaMcpScope = 'mcp:connect'
+
+export const FigmaOAuthCredentialSlot = CredentialSlot.make({
+  id: figmaOAuthSlotId,
+  kind: 'oauth',
+  requiredScopes: [figmaMcpScope]
+})
+
+const resolveFigmaAccessToken = (integration: ConnectorIntegration) =>
+  Effect.gen(function* () {
+    const credential = yield* resolveCredential(integration, FigmaOAuthCredentialSlot)
+
+    switch (credential._tag) {
+      case 'OAuthCredential':
+        return {
+          accessToken: credential.accessToken,
+          expiresAt: credential.expiresAt,
+          refreshToken: optionalStringConfig(integration, 'refreshToken')
+        }
+      case 'BearerTokenCredential':
+        return {
+          accessToken: credential.token,
+          expiresAt: credential.expiresAt,
+          refreshToken: optionalStringConfig(integration, 'refreshToken')
+        }
+      case 'ApiKeyCredential':
+        return yield* Effect.fail(
+          new ConnectorError({
+            cause: 'credential_invalid',
+            message: 'Figma connector requires an OAuth or bearer token credential',
+            connectorId: integration.connectorId,
+            slotId: FigmaOAuthCredentialSlot.id
+          })
+        )
+    }
+  })
+
+export class FigmaMcpAuthInput extends Schema.Class<FigmaMcpAuthInput>('FigmaMcpAuthInput')({}) {}
+
+export class FigmaMcpTokens extends Schema.Class<FigmaMcpTokens>('FigmaMcpTokens')({
+  accessToken: Schema.String,
+  refreshToken: Schema.optional(Schema.String),
+  expiresAt: Schema.optional(Schema.Number)
+}) {}
+
+export class FigmaMcpClientInfo extends Schema.Class<FigmaMcpClientInfo>('FigmaMcpClientInfo')({
+  clientId: Schema.optional(Schema.String),
+  clientSecret: Schema.optional(Schema.String)
+}) {}
+
+export class FigmaMcpAuthOutput extends Schema.Class<FigmaMcpAuthOutput>('FigmaMcpAuthOutput')({
+  provider: Schema.Literal('figma'),
+  serverUrl: Schema.String,
+  tokens: FigmaMcpTokens,
+  clientInfo: FigmaMcpClientInfo
+}) {}
+
+export const makeFigmaMcpAuthData = (input: {
+  readonly accessToken: string
+  readonly refreshToken?: string
+  readonly expiresAt?: number
+  readonly clientId?: string
+  readonly clientSecret?: string
+}) =>
+  FigmaMcpAuthOutput.make({
+    provider: 'figma',
+    serverUrl: figmaMcpServerUrl,
+    tokens: FigmaMcpTokens.make({
+      accessToken: input.accessToken,
+      refreshToken: input.refreshToken,
+      expiresAt: input.expiresAt
+    }),
+    clientInfo: FigmaMcpClientInfo.make({
+      clientId: input.clientId,
+      clientSecret: input.clientSecret
+    })
+  })
+
+export const figmaMcpAuthAction = defineAction({
+  id: 'figma.mcp_auth',
+  description: 'Build Figma remote MCP auth data from host-provided OAuth credentials.',
+  inputSchema: FigmaMcpAuthInput,
+  outputSchema: FigmaMcpAuthOutput,
+  execute: ({ integration }) =>
+    Effect.gen(function* () {
+      const token = yield* resolveFigmaAccessToken(integration)
+      return ActionResult.success(
+        makeFigmaMcpAuthData({
+          accessToken: token.accessToken,
+          refreshToken: token.refreshToken,
+          expiresAt: token.expiresAt,
+          clientId: optionalStringConfig(integration, 'clientId'),
+          clientSecret: optionalStringConfig(integration, 'clientSecret')
+        })
+      )
+    })
+})
+
+export const figmaActions = [figmaMcpAuthAction]
+
+export const FigmaConnector = defineConnector({
+  id: figmaConnectorId,
+  description: 'Figma remote MCP connector actions.',
+  actions: figmaActions
+})

package/src/google/calendar.ts

@@ -0,0 +1,145 @@
+import { Effect } from 'effect'
+import * as Schema from 'effect/Schema'
+import { defineAction } from '../action.ts'
+import { ConnectorHttpClient, ConnectorHttpRequest, decodeJsonResponse } from '../http.ts'
+import { ActionResult } from '../result.ts'
+import { googleAuthorizationHeaders } from './oauth.ts'
+import {
+  appendNumberSearchParam,
+  appendSearchParam,
+  isSuccessStatus,
+  providerFailureFromResponse,
+  resolveGoogleAccessToken
+} from './shared.ts'
+
+export const googleCalendarApiBaseUrl = 'https://www.googleapis.com/calendar/v3'
+
+export class GoogleCalendarEventDateTime extends Schema.Class<GoogleCalendarEventDateTime>(
+  'GoogleCalendarEventDateTime'
+)({
+  date: Schema.optional(Schema.String),
+  dateTime: Schema.optional(Schema.String),
+  timeZone: Schema.optional(Schema.String)
+}) {}
+
+export class GoogleCalendarEvent extends Schema.Class<GoogleCalendarEvent>('GoogleCalendarEvent')({
+  id: Schema.optional(Schema.String),
+  status: Schema.optional(Schema.String),
+  htmlLink: Schema.optional(Schema.String),
+  summary: Schema.optional(Schema.String),
+  description: Schema.optional(Schema.String),
+  location: Schema.optional(Schema.String),
+  start: Schema.optional(GoogleCalendarEventDateTime),
+  end: Schema.optional(GoogleCalendarEventDateTime)
+}) {}
+
+export class GoogleCalendarListEventsInput extends Schema.Class<GoogleCalendarListEventsInput>(
+  'GoogleCalendarListEventsInput'
+)({
+  calendarId: Schema.optional(Schema.String),
+  timeMin: Schema.optional(Schema.String),
+  timeMax: Schema.optional(Schema.String),
+  query: Schema.optional(Schema.String),
+  maxResults: Schema.optional(Schema.Number)
+}) {}
+
+export class GoogleCalendarListEventsOutput extends Schema.Class<GoogleCalendarListEventsOutput>(
+  'GoogleCalendarListEventsOutput'
+)({
+  items: Schema.optional(Schema.Array(GoogleCalendarEvent)),
+  nextPageToken: Schema.optional(Schema.String)
+}) {}
+
+export class GoogleCalendarCreateEventInput extends Schema.Class<GoogleCalendarCreateEventInput>(
+  'GoogleCalendarCreateEventInput'
+)({
+  calendarId: Schema.optional(Schema.String),
+  summary: Schema.String,
+  description: Schema.optional(Schema.String),
+  location: Schema.optional(Schema.String),
+  start: GoogleCalendarEventDateTime,
+  end: GoogleCalendarEventDateTime
+}) {}
+
+const calendarIdOrPrimary = (calendarId: string | undefined) => calendarId ?? 'primary'
+
+export const googleCalendarListEventsAction = defineAction({
+  id: 'calendar.list_events',
+  description: 'List Google Calendar events for the integration account.',
+  inputSchema: GoogleCalendarListEventsInput,
+  outputSchema: GoogleCalendarListEventsOutput,
+  execute: ({ integration, input }) =>
+    Effect.gen(function* () {
+      const token = yield* resolveGoogleAccessToken(integration)
+      const http = yield* ConnectorHttpClient
+      const params = new URLSearchParams()
+      appendSearchParam(params, 'timeMin', input.timeMin)
+      appendSearchParam(params, 'timeMax', input.timeMax)
+      appendSearchParam(params, 'q', input.query)
+      appendNumberSearchParam(params, 'maxResults', input.maxResults)
+      const query = params.toString()
+      const url = `${googleCalendarApiBaseUrl}/calendars/${encodeURIComponent(calendarIdOrPrimary(input.calendarId))}/events${query === '' ? '' : `?${query}`}`
+      const response = yield* http.request(
+        ConnectorHttpRequest.make({
+          method: 'GET',
+          url,
+          headers: googleAuthorizationHeaders(token)
+        })
+      )
+
+      if (!isSuccessStatus(response.status)) {
+        return providerFailureFromResponse({
+          code: 'calendar_list_events_failed',
+          message: 'Google Calendar list events failed',
+          status: response.status,
+          body: response.body
+        })
+      }
+
+      const output = yield* decodeJsonResponse(GoogleCalendarListEventsOutput, response)
+      return ActionResult.success(output)
+    })
+})
+
+export const googleCalendarCreateEventAction = defineAction({
+  id: 'calendar.create_event',
+  description: 'Create a Google Calendar event for the integration account.',
+  inputSchema: GoogleCalendarCreateEventInput,
+  outputSchema: GoogleCalendarEvent,
+  execute: ({ integration, input }) =>
+    Effect.gen(function* () {
+      const token = yield* resolveGoogleAccessToken(integration)
+      const http = yield* ConnectorHttpClient
+      const response = yield* http.request(
+        ConnectorHttpRequest.make({
+          method: 'POST',
+          url: `${googleCalendarApiBaseUrl}/calendars/${encodeURIComponent(calendarIdOrPrimary(input.calendarId))}/events`,
+          headers: {
+            ...googleAuthorizationHeaders(token),
+            'content-type': 'application/json'
+          },
+          body: JSON.stringify({
+            summary: input.summary,
+            description: input.description,
+            location: input.location,
+            start: input.start,
+            end: input.end
+          })
+        })
+      )
+
+      if (!isSuccessStatus(response.status)) {
+        return providerFailureFromResponse({
+          code: 'calendar_create_event_failed',
+          message: 'Google Calendar create event failed',
+          status: response.status,
+          body: response.body
+        })
+      }
+
+      const output = yield* decodeJsonResponse(GoogleCalendarEvent, response)
+      return ActionResult.success(output)
+    })
+})
+
+export const googleCalendarActions = [googleCalendarListEventsAction, googleCalendarCreateEventAction]

package/src/google/gmail.ts

@@ -0,0 +1,127 @@
+import { Effect } from 'effect'
+import * as Schema from 'effect/Schema'
+import { defineAction } from '../action.ts'
+import { ConnectorHttpClient, ConnectorHttpRequest, decodeJsonResponse } from '../http.ts'
+import { ActionResult } from '../result.ts'
+import { googleAuthorizationHeaders } from './oauth.ts'
+import {
+  appendNumberSearchParam,
+  appendSearchParam,
+  isSuccessStatus,
+  providerFailureFromResponse,
+  resolveGoogleAccessToken
+} from './shared.ts'
+
+export const googleGmailApiBaseUrl = 'https://gmail.googleapis.com/gmail/v1'
+
+export class GmailMessageRef extends Schema.Class<GmailMessageRef>('GmailMessageRef')({
+  id: Schema.String,
+  threadId: Schema.optional(Schema.String)
+}) {}
+
+export class GmailSearchInput extends Schema.Class<GmailSearchInput>('GmailSearchInput')({
+  query: Schema.optional(Schema.String),
+  maxResults: Schema.optional(Schema.Number)
+}) {}
+
+export class GmailSearchOutput extends Schema.Class<GmailSearchOutput>('GmailSearchOutput')({
+  messages: Schema.optional(Schema.Array(GmailMessageRef)),
+  nextPageToken: Schema.optional(Schema.String),
+  resultSizeEstimate: Schema.optional(Schema.Number)
+}) {}
+
+export class GmailGetMessageInput extends Schema.Class<GmailGetMessageInput>('GmailGetMessageInput')({
+  id: Schema.String,
+  format: Schema.optional(Schema.Literals(['minimal', 'full', 'raw', 'metadata']))
+}) {}
+
+export const GmailMessagePayloadHeader = Schema.Struct({
+  name: Schema.String,
+  value: Schema.String
+})
+
+export class GmailMessageOutput extends Schema.Class<GmailMessageOutput>('GmailMessageOutput')({
+  id: Schema.String,
+  threadId: Schema.optional(Schema.String),
+  snippet: Schema.optional(Schema.String),
+  labelIds: Schema.optional(Schema.Array(Schema.String)),
+  payload: Schema.optional(
+    Schema.Struct({
+      headers: Schema.optional(Schema.Array(GmailMessagePayloadHeader))
+    })
+  ),
+  raw: Schema.optional(Schema.String)
+}) {}
+
+export const gmailSearchAction = defineAction({
+  id: 'gmail.search',
+  description: 'Search Gmail messages for the integration account.',
+  inputSchema: GmailSearchInput,
+  outputSchema: GmailSearchOutput,
+  execute: ({ integration, input }) =>
+    Effect.gen(function* () {
+      const token = yield* resolveGoogleAccessToken(integration)
+      const http = yield* ConnectorHttpClient
+      const params = new URLSearchParams()
+      appendSearchParam(params, 'q', input.query)
+      appendNumberSearchParam(params, 'maxResults', input.maxResults)
+      const query = params.toString()
+      const url = `${googleGmailApiBaseUrl}/users/me/messages${query === '' ? '' : `?${query}`}`
+      const response = yield* http.request(
+        ConnectorHttpRequest.make({
+          method: 'GET',
+          url,
+          headers: googleAuthorizationHeaders(token)
+        })
+      )
+
+      if (!isSuccessStatus(response.status)) {
+        return providerFailureFromResponse({
+          code: 'gmail_search_failed',
+          message: 'Gmail search failed',
+          status: response.status,
+          body: response.body
+        })
+      }
+
+      const output = yield* decodeJsonResponse(GmailSearchOutput, response)
+      return ActionResult.success(output)
+    })
+})
+
+export const gmailGetMessageAction = defineAction({
+  id: 'gmail.get_message',
+  description: 'Get a Gmail message by id for the integration account.',
+  inputSchema: GmailGetMessageInput,
+  outputSchema: GmailMessageOutput,
+  execute: ({ integration, input }) =>
+    Effect.gen(function* () {
+      const token = yield* resolveGoogleAccessToken(integration)
+      const http = yield* ConnectorHttpClient
+      const params = new URLSearchParams()
+      appendSearchParam(params, 'format', input.format)
+      const query = params.toString()
+      const url = `${googleGmailApiBaseUrl}/users/me/messages/${encodeURIComponent(input.id)}${query === '' ? '' : `?${query}`}`
+      const response = yield* http.request(
+        ConnectorHttpRequest.make({
+          method: 'GET',
+          url,
+          headers: googleAuthorizationHeaders(token)
+        })
+      )
+
+      if (!isSuccessStatus(response.status)) {
+        return providerFailureFromResponse({
+          code: 'gmail_get_message_failed',
+          message: 'Gmail get message failed',
+          status: response.status,
+          body: response.body
+        })
+      }
+
+      const output = yield* decodeJsonResponse(GmailMessageOutput, response)
+      return ActionResult.success(output)
+    })
+})
+
+export const gmailActions = [gmailSearchAction, gmailGetMessageAction]

package/src/google/index.ts

@@ -0,0 +1,46 @@
+export {
+  googleCalendarActions,
+  googleCalendarApiBaseUrl,
+  googleCalendarCreateEventAction,
+  googleCalendarListEventsAction,
+  GoogleCalendarCreateEventInput,
+  GoogleCalendarEvent,
+  GoogleCalendarEventDateTime,
+  GoogleCalendarListEventsInput,
+  GoogleCalendarListEventsOutput
+} from './calendar.ts'
+export {
+  gmailActions,
+  gmailGetMessageAction,
+  GmailGetMessageInput,
+  gmailSearchAction,
+  GmailMessageOutput,
+  GmailMessageRef,
+  GmailSearchInput,
+  GmailSearchOutput,
+  googleGmailApiBaseUrl
+} from './gmail.ts'
+export {
+  GoogleOAuthCredentialSlot,
+  googleAuthorizationHeaders,
+  googleCalendarEventsScope,
+  googleCalendarReadonlyScope,
+  googleConnectorId,
+  googleGmailReadonlyScope,
+  googleGmailSendScope,
+  googleOAuthAuthorizeUrl,
+  googleOAuthSlotId,
+  googleOAuthTokenUrl
+} from './oauth.ts'
+export { resolveGoogleAccessToken } from './shared.ts'
+
+import { defineConnector } from '../connector.ts'
+import { googleCalendarActions } from './calendar.ts'
+import { gmailActions } from './gmail.ts'
+import { googleConnectorId } from './oauth.ts'
+
+export const GoogleConnector = defineConnector({
+  id: googleConnectorId,
+  description: 'Google Gmail and Calendar connector actions.',
+  actions: [...gmailActions, ...googleCalendarActions]
+})

package/src/google/oauth.ts

@@ -0,0 +1,26 @@
+import { CredentialSlot } from '../credential.ts'
+
+export const googleConnectorId = 'google'
+export const googleOAuthSlotId = 'google.oauth'
+export const googleOAuthAuthorizeUrl = 'https://accounts.google.com/o/oauth2/v2/auth'
+export const googleOAuthTokenUrl = 'https://oauth2.googleapis.com/token'
+
+export const googleGmailReadonlyScope = 'https://www.googleapis.com/auth/gmail.readonly'
+export const googleGmailSendScope = 'https://www.googleapis.com/auth/gmail.send'
+export const googleCalendarReadonlyScope = 'https://www.googleapis.com/auth/calendar.readonly'
+export const googleCalendarEventsScope = 'https://www.googleapis.com/auth/calendar.events'
+
+export const GoogleOAuthCredentialSlot = CredentialSlot.make({
+  id: googleOAuthSlotId,
+  kind: 'oauth',
+  requiredScopes: [
+    googleGmailReadonlyScope,
+    googleGmailSendScope,
+    googleCalendarReadonlyScope,
+    googleCalendarEventsScope
+  ]
+})
+
+export const googleAuthorizationHeaders = (accessToken: string) => ({
+  authorization: `Bearer ${accessToken}`
+})

package/src/google/shared.ts

@@ -0,0 +1,56 @@
+import { Effect } from 'effect'
+import { resolveCredential } from '../credential.ts'
+import { ConnectorError } from '../error.ts'
+import { ActionResult, ProviderFailure } from '../result.ts'
+import type { ConnectorIntegration } from '../integration.ts'
+import { GoogleOAuthCredentialSlot } from './oauth.ts'
+
+export const resolveGoogleAccessToken = (integration: ConnectorIntegration) =>
+  Effect.gen(function* () {
+    const credential = yield* resolveCredential(integration, GoogleOAuthCredentialSlot)
+
+    switch (credential._tag) {
+      case 'OAuthCredential':
+        return credential.accessToken
+      case 'BearerTokenCredential':
+        return credential.token
+      case 'ApiKeyCredential':
+        return yield* Effect.fail(
+          new ConnectorError({
+            cause: 'credential_invalid',
+            message: 'Google connector requires an OAuth or bearer token credential',
+            connectorId: integration.connectorId,
+            slotId: GoogleOAuthCredentialSlot.id
+          })
+        )
+    }
+  })
+
+export const providerFailureFromResponse = (input: {
+  readonly code: string
+  readonly message: string
+  readonly status: number
+  readonly body: string
+}) =>
+  ActionResult.failure(
+    new ProviderFailure({
+      code: input.code,
+      message: input.message,
+      status: input.status,
+      underlying: input.body
+    })
+  )
+
+export const isSuccessStatus = (status: number) => status >= 200 && status < 300
+
+export const appendSearchParam = (params: URLSearchParams, key: string, value: string | undefined) => {
+  if (value !== undefined && value.trim() !== '') {
+    params.set(key, value)
+  }
+}
+
+export const appendNumberSearchParam = (params: URLSearchParams, key: string, value: number | undefined) => {
+  if (value !== undefined) {
+    params.set(key, String(value))
+  }
+}