@yolk-sdk/connectors 0.0.1-canary.0

package/src/http.ts

@@ -0,0 +1,51 @@
+import { Context, Effect } from 'effect'
+import * as Schema from 'effect/Schema'
+import { ConnectorError } from './error.ts'
+
+export const HttpMethod = Schema.Literals(['GET', 'POST', 'PATCH', 'PUT', 'DELETE'])
+export type HttpMethod = typeof HttpMethod.Type
+
+export class ConnectorHttpRequest extends Schema.Class<ConnectorHttpRequest>('ConnectorHttpRequest')({
+  method: HttpMethod,
+  url: Schema.String,
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+  body: Schema.optional(Schema.String)
+}) {}
+
+export class ConnectorHttpResponse extends Schema.Class<ConnectorHttpResponse>('ConnectorHttpResponse')({
+  status: Schema.Number,
+  headers: Schema.Record(Schema.String, Schema.String),
+  body: Schema.String
+}) {}
+
+export type ConnectorHttpClientApi = {
+  readonly request: (request: ConnectorHttpRequest) => Effect.Effect<ConnectorHttpResponse, ConnectorError>
+}
+
+export class ConnectorHttpClient extends Context.Service<ConnectorHttpClient, ConnectorHttpClientApi>()(
+  '@yolk-sdk/connectors/ConnectorHttpClient'
+) {}
+
+type JsonResponseSchema<A> = Schema.Schema<A> & { readonly DecodingServices: never }
+
+export const decodeJsonResponse = <A>(schema: JsonResponseSchema<A>, response: ConnectorHttpResponse) =>
+  Schema.decodeUnknownEffect(Schema.UnknownFromJsonString)(response.body).pipe(
+    Effect.mapError(error =>
+      new ConnectorError({
+        cause: 'validation_failed',
+        message: 'Invalid JSON response',
+        underlying: error
+      })
+    ),
+    Effect.flatMap(value =>
+      Schema.decodeUnknownEffect(schema)(value).pipe(
+        Effect.mapError(error =>
+          new ConnectorError({
+            cause: 'validation_failed',
+            message: 'Invalid response shape',
+            underlying: error
+          })
+        )
+      )
+    )
+  )

package/src/index.ts

@@ -0,0 +1,36 @@
+export { defineAction } from './action.ts'
+export type {
+  ActionExecutionInput,
+  ConnectorAction,
+  DefineActionOptions,
+  UnknownActionExecutionInput
+} from './action.ts'
+export { defineConnector } from './connector.ts'
+export type { Connector, ConnectorInvokeInput, DefineConnectorOptions } from './connector.ts'
+export {
+  ApiKeyCredential,
+  BearerTokenCredential,
+  CredentialBinding,
+  CredentialKind,
+  CredentialResolver,
+  CredentialSlot,
+  OAuthCredential,
+  RuntimeCredential,
+  findCredentialBinding,
+  makeCredentialBinding,
+  resolveCredential
+} from './credential.ts'
+export type { CredentialResolveRequest, CredentialResolverApi } from './credential.ts'
+export { ConnectorError, ConnectorErrorCause } from './error.ts'
+export { optionalStringConfig, requiredStringConfig } from './config.ts'
+export {
+  ConnectorHttpClient,
+  ConnectorHttpRequest,
+  ConnectorHttpResponse,
+  HttpMethod,
+  decodeJsonResponse
+} from './http.ts'
+export type { ConnectorHttpClientApi } from './http.ts'
+export { ConnectorIntegration, IntegrationConfig, makeIntegration } from './integration.ts'
+export { ActionResult, ProviderFailure } from './result.ts'
+export type { ActionResult as ActionResultType } from './result.ts'

package/src/integration.ts

@@ -0,0 +1,28 @@
+import * as Schema from 'effect/Schema'
+import { CredentialBinding } from './credential.ts'
+
+export const IntegrationConfig = Schema.Record(Schema.String, Schema.Unknown)
+export type IntegrationConfig = typeof IntegrationConfig.Type
+
+export class ConnectorIntegration extends Schema.Class<ConnectorIntegration>('ConnectorIntegration')({
+  id: Schema.optional(Schema.String),
+  connectorId: Schema.String,
+  config: IntegrationConfig,
+  credentialBindings: Schema.Array(CredentialBinding),
+  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown))
+}) {}
+
+export const makeIntegration = (input: {
+  readonly id?: string
+  readonly connectorId: string
+  readonly config?: IntegrationConfig
+  readonly credentialBindings?: ReadonlyArray<CredentialBinding>
+  readonly metadata?: Readonly<Record<string, unknown>>
+}) =>
+  ConnectorIntegration.make({
+    id: input.id,
+    connectorId: input.connectorId,
+    config: input.config ?? {},
+    credentialBindings: input.credentialBindings ?? [],
+    metadata: input.metadata
+  })

package/src/linkedin-search/index.ts

@@ -0,0 +1,217 @@
+import { Effect } from 'effect'
+import * as Schema from 'effect/Schema'
+import { defineAction } from '../action.ts'
+import { defineConnector } from '../connector.ts'
+import { CredentialSlot, resolveCredential } from '../credential.ts'
+import { ConnectorError } from '../error.ts'
+import { ConnectorHttpClient, ConnectorHttpRequest, decodeJsonResponse } from '../http.ts'
+import { ActionResult, ProviderFailure } from '../result.ts'
+import type { ConnectorIntegration } from '../integration.ts'
+
+export const linkedInSearchConnectorId = 'linkedin-search'
+export const exaApiKeySlotId = 'linkedin-search.exa_api_key'
+export const enrichLayerApiKeySlotId = 'linkedin-search.enrich_layer_api_key'
+export const exaApiBaseUrl = 'https://api.exa.ai'
+export const enrichLayerApiBaseUrl = 'https://enrichlayer.com/api/v2'
+
+export const ExaApiKeySlot = CredentialSlot.make({ id: exaApiKeySlotId, kind: 'api_key' })
+export const EnrichLayerApiKeySlot = CredentialSlot.make({
+  id: enrichLayerApiKeySlotId,
+  kind: 'api_key'
+})
+
+const resolveApiToken = (integration: ConnectorIntegration, slot: CredentialSlot) =>
+  Effect.gen(function* () {
+    const credential = yield* resolveCredential(integration, slot)
+
+    switch (credential._tag) {
+      case 'ApiKeyCredential':
+        return credential.key
+      case 'BearerTokenCredential':
+        return credential.token
+      case 'OAuthCredential':
+        return credential.accessToken
+    }
+  })
+
+const isSuccessStatus = (status: number) => status >= 200 && status < 300
+
+const linkedInProviderFailure = (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 class LinkedInSearchInput extends Schema.Class<LinkedInSearchInput>('LinkedInSearchInput')({
+  query: Schema.String,
+  numResults: Schema.optional(Schema.Number)
+}) {}
+
+export const LinkedInSearchResult = Schema.Struct({
+  title: Schema.optional(Schema.String),
+  url: Schema.optional(Schema.String),
+  text: Schema.optional(Schema.String),
+  publishedDate: Schema.optional(Schema.String),
+  author: Schema.optional(Schema.String)
+})
+
+export class LinkedInSearchOutput extends Schema.Class<LinkedInSearchOutput>('LinkedInSearchOutput')({
+  results: Schema.Array(LinkedInSearchResult),
+  totalResults: Schema.optional(Schema.Number)
+}) {}
+
+export class LinkedInProfileInput extends Schema.Class<LinkedInProfileInput>('LinkedInProfileInput')({
+  linkedinUrl: Schema.String
+}) {}
+
+export class LinkedInProfileOutput extends Schema.Class<LinkedInProfileOutput>('LinkedInProfileOutput')({
+  profile: Schema.Unknown
+}) {}
+
+export class LinkedInEmailOutput extends Schema.Class<LinkedInEmailOutput>('LinkedInEmailOutput')({
+  email: Schema.NullOr(Schema.String),
+  status: Schema.optional(Schema.String),
+  message: Schema.optional(Schema.String)
+}) {}
+
+const missingEnrichLayer = (integration: ConnectorIntegration) =>
+  new ConnectorError({
+    cause: 'credential_binding_missing',
+    message: 'Missing Enrich Layer credential binding',
+    connectorId: integration.connectorId,
+    slotId: EnrichLayerApiKeySlot.id
+  })
+
+export const linkedInSearchAction = defineAction({
+  id: 'linkedin_search.search',
+  description: 'Search LinkedIn people results through Exa.',
+  inputSchema: LinkedInSearchInput,
+  outputSchema: LinkedInSearchOutput,
+  execute: ({ integration, input }) =>
+    Effect.gen(function* () {
+      const token = yield* resolveApiToken(integration, ExaApiKeySlot)
+      const http = yield* ConnectorHttpClient
+      const response = yield* http.request(
+        ConnectorHttpRequest.make({
+          method: 'POST',
+          url: `${exaApiBaseUrl}/search`,
+          headers: {
+            authorization: `Bearer ${token}`,
+            'content-type': 'application/json'
+          },
+          body: JSON.stringify({
+            query: input.query,
+            category: 'people',
+            numResults: input.numResults ?? 10,
+            type: 'auto',
+            contents: { text: true }
+          })
+        })
+      )
+
+      if (!isSuccessStatus(response.status)) {
+        return linkedInProviderFailure({
+          code: 'linkedin_search_failed',
+          message: 'LinkedIn search failed',
+          status: response.status,
+          body: response.body
+        })
+      }
+
+      const decoded = yield* decodeJsonResponse(
+        Schema.Struct({ results: Schema.Array(LinkedInSearchResult), totalResults: Schema.optional(Schema.Number) }),
+        response
+      )
+      return ActionResult.success(LinkedInSearchOutput.make(decoded))
+    })
+})
+
+export const linkedInProfileAction = defineAction({
+  id: 'linkedin_search.profile',
+  description: 'Fetch a LinkedIn profile through Enrich Layer.',
+  inputSchema: LinkedInProfileInput,
+  outputSchema: LinkedInProfileOutput,
+  execute: ({ integration, input }) =>
+    Effect.gen(function* () {
+      const token = yield* resolveApiToken(integration, EnrichLayerApiKeySlot).pipe(
+        Effect.catchTag('ConnectorError', () => Effect.fail(missingEnrichLayer(integration)))
+      )
+      const http = yield* ConnectorHttpClient
+      const response = yield* http.request(
+        ConnectorHttpRequest.make({
+          method: 'GET',
+          url: `${enrichLayerApiBaseUrl}/profile?linkedin_profile_url=${encodeURIComponent(input.linkedinUrl)}`,
+          headers: { authorization: `Bearer ${token}` }
+        })
+      )
+
+      if (!isSuccessStatus(response.status)) {
+        return linkedInProviderFailure({
+          code: 'linkedin_profile_failed',
+          message: 'LinkedIn profile fetch failed',
+          status: response.status,
+          body: response.body
+        })
+      }
+
+      const profile = yield* decodeJsonResponse(Schema.Unknown, response)
+      return ActionResult.success(LinkedInProfileOutput.make({ profile }))
+    })
+})
+
+export const linkedInEmailAction = defineAction({
+  id: 'linkedin_search.email',
+  description: 'Fetch a LinkedIn profile email through Enrich Layer.',
+  inputSchema: LinkedInProfileInput,
+  outputSchema: LinkedInEmailOutput,
+  execute: ({ integration, input }) =>
+    Effect.gen(function* () {
+      const token = yield* resolveApiToken(integration, EnrichLayerApiKeySlot).pipe(
+        Effect.catchTag('ConnectorError', () => Effect.fail(missingEnrichLayer(integration)))
+      )
+      const http = yield* ConnectorHttpClient
+      const response = yield* http.request(
+        ConnectorHttpRequest.make({
+          method: 'GET',
+          url: `${enrichLayerApiBaseUrl}/profile/email?linkedin_profile_url=${encodeURIComponent(input.linkedinUrl)}`,
+          headers: { authorization: `Bearer ${token}` }
+        })
+      )
+
+      if (!isSuccessStatus(response.status)) {
+        return linkedInProviderFailure({
+          code: 'linkedin_email_failed',
+          message: 'LinkedIn email fetch failed',
+          status: response.status,
+          body: response.body
+        })
+      }
+
+      const decoded = yield* decodeJsonResponse(
+        Schema.Struct({
+          email: Schema.NullOr(Schema.String),
+          status: Schema.optional(Schema.String),
+          message: Schema.optional(Schema.String)
+        }),
+        response
+      )
+      return ActionResult.success(LinkedInEmailOutput.make(decoded))
+    })
+})
+
+export const linkedInSearchActions = [linkedInSearchAction, linkedInProfileAction, linkedInEmailAction]
+
+export const LinkedInSearchConnector = defineConnector({
+  id: linkedInSearchConnectorId,
+  description: 'LinkedIn people search and enrichment connector actions.',
+  actions: linkedInSearchActions
+})

package/src/notion/index.ts

@@ -0,0 +1,234 @@
+import { Effect } from 'effect'
+import * as Schema from 'effect/Schema'
+import { defineAction } from '../action.ts'
+import { defineConnector } from '../connector.ts'
+import { CredentialSlot, resolveCredential } from '../credential.ts'
+import { ConnectorHttpClient, ConnectorHttpRequest, decodeJsonResponse } from '../http.ts'
+import { ActionResult, ProviderFailure } from '../result.ts'
+import type { ConnectorIntegration } from '../integration.ts'
+
+export const notionConnectorId = 'notion'
+export const notionApiTokenSlotId = 'notion.api_token'
+export const notionApiBaseUrl = 'https://api.notion.com/v1'
+export const notionVersion = '2022-06-28'
+
+export const NotionApiTokenSlot = CredentialSlot.make({
+  id: notionApiTokenSlotId,
+  kind: 'api_key'
+})
+
+export const notionAuthorizationHeaders = (token: string) => ({
+  authorization: `Bearer ${token}`,
+  'notion-version': notionVersion
+})
+
+const isSuccessStatus = (status: number) => status >= 200 && status < 300
+
+const notionProviderFailure = (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
+    })
+  )
+
+const resolveNotionToken = (integration: ConnectorIntegration) =>
+  Effect.gen(function* () {
+    const credential = yield* resolveCredential(integration, NotionApiTokenSlot)
+
+    switch (credential._tag) {
+      case 'ApiKeyCredential':
+        return credential.key
+      case 'BearerTokenCredential':
+        return credential.token
+      case 'OAuthCredential':
+        return credential.accessToken
+    }
+  })
+
+export const NotionRichText = Schema.Struct({
+  type: Schema.optional(Schema.String),
+  plain_text: Schema.optional(Schema.String),
+  href: Schema.optional(Schema.NullOr(Schema.String))
+})
+
+export const NotionTitleProperty = Schema.Struct({
+  title: Schema.Array(NotionRichText)
+})
+
+export const NotionProperties = Schema.Record(Schema.String, Schema.Unknown)
+
+export class NotionPage extends Schema.Class<NotionPage>('NotionPage')({
+  id: Schema.String,
+  object: Schema.String,
+  url: Schema.optional(Schema.String),
+  archived: Schema.optional(Schema.Boolean),
+  properties: Schema.optional(NotionProperties)
+}) {}
+
+export class NotionSearchInput extends Schema.Class<NotionSearchInput>('NotionSearchInput')({
+  query: Schema.optional(Schema.String),
+  pageSize: Schema.optional(Schema.Number),
+  startCursor: Schema.optional(Schema.String)
+}) {}
+
+export class NotionSearchOutput extends Schema.Class<NotionSearchOutput>('NotionSearchOutput')({
+  results: Schema.Array(Schema.Unknown),
+  nextCursor: Schema.optional(Schema.NullOr(Schema.String)),
+  hasMore: Schema.Boolean
+}) {}
+
+export class NotionGetPageInput extends Schema.Class<NotionGetPageInput>('NotionGetPageInput')({
+  pageId: Schema.String
+}) {}
+
+export class NotionCreatePageInput extends Schema.Class<NotionCreatePageInput>('NotionCreatePageInput')({
+  parentPageId: Schema.optional(Schema.String),
+  parentDatabaseId: Schema.optional(Schema.String),
+  title: Schema.String,
+  properties: Schema.optional(NotionProperties)
+}) {}
+
+const pageParent = (input: NotionCreatePageInput) => {
+  if (input.parentDatabaseId !== undefined) {
+    return { database_id: input.parentDatabaseId }
+  }
+
+  return { page_id: input.parentPageId ?? '' }
+}
+
+const pageProperties = (input: NotionCreatePageInput) => ({
+  ...input.properties,
+  title: {
+    title: [
+      {
+        text: {
+          content: input.title
+        }
+      }
+    ]
+  }
+})
+
+export const notionSearchAction = defineAction({
+  id: 'notion.search',
+  description: 'Search pages and databases available to the Notion integration.',
+  inputSchema: NotionSearchInput,
+  outputSchema: NotionSearchOutput,
+  execute: ({ integration, input }) =>
+    Effect.gen(function* () {
+      const token = yield* resolveNotionToken(integration)
+      const http = yield* ConnectorHttpClient
+      const response = yield* http.request(
+        ConnectorHttpRequest.make({
+          method: 'POST',
+          url: `${notionApiBaseUrl}/search`,
+          headers: {
+            ...notionAuthorizationHeaders(token),
+            'content-type': 'application/json'
+          },
+          body: JSON.stringify({
+            query: input.query,
+            page_size: input.pageSize,
+            start_cursor: input.startCursor
+          })
+        })
+      )
+
+      if (!isSuccessStatus(response.status)) {
+        return notionProviderFailure({
+          code: 'notion_search_failed',
+          message: 'Notion search failed',
+          status: response.status,
+          body: response.body
+        })
+      }
+
+      const output = yield* decodeJsonResponse(NotionSearchOutput, response)
+      return ActionResult.success(output)
+    })
+})
+
+export const notionGetPageAction = defineAction({
+  id: 'notion.get_page',
+  description: 'Get a Notion page by id.',
+  inputSchema: NotionGetPageInput,
+  outputSchema: NotionPage,
+  execute: ({ integration, input }) =>
+    Effect.gen(function* () {
+      const token = yield* resolveNotionToken(integration)
+      const http = yield* ConnectorHttpClient
+      const response = yield* http.request(
+        ConnectorHttpRequest.make({
+          method: 'GET',
+          url: `${notionApiBaseUrl}/pages/${encodeURIComponent(input.pageId)}`,
+          headers: notionAuthorizationHeaders(token)
+        })
+      )
+
+      if (!isSuccessStatus(response.status)) {
+        return notionProviderFailure({
+          code: 'notion_get_page_failed',
+          message: 'Notion get page failed',
+          status: response.status,
+          body: response.body
+        })
+      }
+
+      const output = yield* decodeJsonResponse(NotionPage, response)
+      return ActionResult.success(output)
+    })
+})
+
+export const notionCreatePageAction = defineAction({
+  id: 'notion.create_page',
+  description: 'Create a Notion page under a parent page or database.',
+  inputSchema: NotionCreatePageInput,
+  outputSchema: NotionPage,
+  execute: ({ integration, input }) =>
+    Effect.gen(function* () {
+      const token = yield* resolveNotionToken(integration)
+      const http = yield* ConnectorHttpClient
+      const response = yield* http.request(
+        ConnectorHttpRequest.make({
+          method: 'POST',
+          url: `${notionApiBaseUrl}/pages`,
+          headers: {
+            ...notionAuthorizationHeaders(token),
+            'content-type': 'application/json'
+          },
+          body: JSON.stringify({
+            parent: pageParent(input),
+            properties: pageProperties(input)
+          })
+        })
+      )
+
+      if (!isSuccessStatus(response.status)) {
+        return notionProviderFailure({
+          code: 'notion_create_page_failed',
+          message: 'Notion create page failed',
+          status: response.status,
+          body: response.body
+        })
+      }
+
+      const output = yield* decodeJsonResponse(NotionPage, response)
+      return ActionResult.success(output)
+    })
+})
+
+export const notionActions = [notionSearchAction, notionGetPageAction, notionCreatePageAction]
+
+export const NotionConnector = defineConnector({
+  id: notionConnectorId,
+  description: 'Notion page and search connector actions.',
+  actions: notionActions
+})

package/src/r2-storage/index.ts

@@ -0,0 +1,118 @@
+import { Context, Effect } from 'effect'
+import * as Schema from 'effect/Schema'
+import { defineAction } from '../action.ts'
+import { requiredStringConfig } from '../config.ts'
+import { defineConnector } from '../connector.ts'
+import { CredentialSlot, resolveCredential } from '../credential.ts'
+import { ActionResult } from '../result.ts'
+import type { ConnectorError } from '../error.ts'
+import type { ConnectorIntegration } from '../integration.ts'
+
+export const r2StorageConnectorId = 'r2-storage'
+export const r2AccessKeyIdSlotId = 'r2-storage.access_key_id'
+export const r2SecretAccessKeySlotId = 'r2-storage.secret_access_key'
+
+export const R2AccessKeyIdSlot = CredentialSlot.make({ id: r2AccessKeyIdSlotId, kind: 'api_key' })
+export const R2SecretAccessKeySlot = CredentialSlot.make({
+  id: r2SecretAccessKeySlotId,
+  kind: 'api_key'
+})
+
+export class R2PresignInput extends Schema.Class<R2PresignInput>('R2PresignInput')({
+  endpoint: Schema.String,
+  accessKeyId: Schema.String,
+  secretAccessKey: Schema.String,
+  bucket: Schema.String,
+  key: Schema.String,
+  contentType: Schema.String
+}) {}
+
+export class R2PresignOutput extends Schema.Class<R2PresignOutput>('R2PresignOutput')({
+  uploadUrl: Schema.String
+}) {}
+
+export type R2PresignerApi = {
+  readonly presignPutObject: (input: R2PresignInput) => Effect.Effect<R2PresignOutput, ConnectorError>
+}
+
+export class R2Presigner extends Context.Service<R2Presigner, R2PresignerApi>()(
+  '@yolk-sdk/connectors/R2Presigner'
+) {}
+
+const resolveApiToken = (integration: ConnectorIntegration, slot: CredentialSlot) =>
+  Effect.gen(function* () {
+    const credential = yield* resolveCredential(integration, slot)
+
+    switch (credential._tag) {
+      case 'ApiKeyCredential':
+        return credential.key
+      case 'BearerTokenCredential':
+        return credential.token
+      case 'OAuthCredential':
+        return credential.accessToken
+    }
+  })
+
+const joinPublicUrl = (publicUrl: string, key: string) => {
+  const base = publicUrl.endsWith('/') ? publicUrl.slice(0, -1) : publicUrl
+  return `${base}/${key}`
+}
+
+const safeObjectKey = (filename: string) => {
+  const trimmed = filename.trim().replace(/^\/+/, '')
+  return trimmed === '' ? `uploads/${Date.now()}` : trimmed
+}
+
+export class R2UploadUrlInput extends Schema.Class<R2UploadUrlInput>('R2UploadUrlInput')({
+  filename: Schema.String,
+  contentType: Schema.String
+}) {}
+
+export class R2UploadUrlOutput extends Schema.Class<R2UploadUrlOutput>('R2UploadUrlOutput')({
+  uploadUrl: Schema.String,
+  publicUrl: Schema.String,
+  key: Schema.String
+}) {}
+
+export const r2StorageUploadUrlAction = defineAction({
+  id: 'r2_storage.upload_url',
+  description: 'Create a presigned R2 PUT upload URL.',
+  inputSchema: R2UploadUrlInput,
+  outputSchema: R2UploadUrlOutput,
+  execute: ({ integration, input }) =>
+    Effect.gen(function* () {
+      const endpoint = yield* requiredStringConfig(integration, 'endpoint')
+      const bucket = yield* requiredStringConfig(integration, 'bucket')
+      const publicUrl = yield* requiredStringConfig(integration, 'publicUrl')
+      const accessKeyId = yield* resolveApiToken(integration, R2AccessKeyIdSlot)
+      const secretAccessKey = yield* resolveApiToken(integration, R2SecretAccessKeySlot)
+      const presigner = yield* R2Presigner
+      const key = safeObjectKey(input.filename)
+      const presigned = yield* presigner.presignPutObject(
+        R2PresignInput.make({
+          endpoint,
+          accessKeyId,
+          secretAccessKey,
+          bucket,
+          key,
+          contentType: input.contentType
+        })
+      )
+
+      return ActionResult.success(
+        R2UploadUrlOutput.make({
+          uploadUrl: presigned.uploadUrl,
+          publicUrl: joinPublicUrl(publicUrl, key),
+          key
+        })
+      )
+    })
+})
+
+export const r2StorageActions = [r2StorageUploadUrlAction]
+
+export const R2StorageConnector = defineConnector({
+  id: r2StorageConnectorId,
+  description: 'Cloudflare R2 storage connector actions.',
+  actions: r2StorageActions
+})