@satorijs/adapter-lark 3.1.3 → 3.1.5

package/src/types/message/index.ts

@@ -0,0 +1,233 @@
+import { Internal, Lark } from '..'
+import { Paginated, Pagination } from '../utils'
+
+import { MessageContent } from './content'
+
+export * from './content'
+export * from './asset'
+
+export type MessageType = 'text' | 'post' | 'image' | 'file' | 'audio' | 'media' | 'sticker' | 'interactive' | 'share_chat' | 'share_user'
+
+export interface MessageContentMap {
+  'text': MessageContent.Text
+  'post': MessageContent.RichText
+  'image': MessageContent.Image
+  'file': MessageContent.File
+  'audio': MessageContent.Audio
+  'media': MessageContent.Media
+  'sticker': MessageContent.Sticker
+  'share_chat': MessageContent.ShareChat
+  'share_user': MessageContent.ShareUser
+}
+
+export type MessageContentType<T extends MessageType> = T extends keyof MessageContentMap ? MessageContentMap[T] : any
+
+export interface Sender extends Lark.UserIdentifiers {
+  sender_type: string
+  tenant_key: string
+}
+export interface Mention extends Lark.UserIdentifiers {
+  key: string
+  name: string
+  tenant_key: string
+}
+
+declare module '../event' {
+  export interface Events {
+    /**
+     * Receive message event.
+     * @see https://open.larksuite.com/document/uAjLw4CM/ukTMukTMukTM/reference/im-v1/message/events/receive
+     */
+    'im.message.receive_v1': EventSkeleton<'im.message.receive_v1', {
+      sender: {
+        sender_id: Lark.UserIds
+        sender_type?: string
+        tenant_key: string
+      }
+      message: {
+        message_id: string
+        root_id: string
+        parent_id: string
+        create_time: string
+        chat_id: string
+        chat_type: string
+        message_type: MessageType
+        content: string
+        mentions: {
+          key: string
+          id: Lark.UserIds
+          name: string
+          tenant_key: string
+        }[]
+      }
+    }>
+    /**
+     * Message read event.
+     * @see https://open.larksuite.com/document/uAjLw4CM/ukTMukTMukTM/reference/im-v1/message/events/message_read
+     */
+    'im.message.message_read_v1': EventSkeleton<'im.message.message_read_v1', {
+      reader: {
+        reader_id: Lark.UserIds
+        read_time: string
+        tenant_key: string
+      }
+      message_id_list: string[]
+    }>
+  }
+}
+
+export interface MessagePayload {
+  receive_id: string
+  content: string
+  msg_type: string
+}
+
+export interface Message {
+  /**
+   * The id of current message
+   *
+   * Should be started with `om_`
+   */
+  message_id: string
+  /**
+   * The id of the *root* message in reply chains
+   * @see https://open.larksuite.com/document/uAjLw4CM/ukTMukTMukTM/reference/im-v1/message/intro#ac79c1c2
+   */
+  root_id: string
+
+  /**
+   * The id of the direct *parent* message in reply chains
+   * @see https://open.larksuite.com/document/uAjLw4CM/ukTMukTMukTM/reference/im-v1/message/intro#ac79c1c2
+   */
+  parent_id: string
+
+  /**
+   * The message type.
+   * @see https://open.larksuite.com/document/uAjLw4CM/ukTMukTMukTM/im-v1/message/create_json
+   */
+  msg_type: MessageType
+
+  /**
+   * The timestamp when the message is created in milliseconds.
+   */
+  create_time: string
+
+  /**
+   * The timestamp when the message is last updated in milliseconds.
+   */
+  update_time: string
+
+  /**
+   * Whether the message is deleted.
+   */
+  deleted: boolean
+
+  /**
+   * Whether the message is updated.
+   */
+  updated: boolean
+
+  /**
+   * The id of the group / channel the message is sent to.
+   */
+  chat_id: string
+
+  /**
+   * The sender of the message.
+   * Can be a user or an app.
+   */
+  sender: Sender
+
+  /**
+   * The body of the message.
+   */
+  body: {
+    /**
+     * The content of the message.
+     * Should be a string that represents the JSON object contains the message content.
+     */
+    content: string
+  }
+
+  /**
+   * Users mentioned in the message.
+   */
+  mentions: Mention[]
+
+  /**
+   * The id of the direct *parent* message in `merge and repost` chains.
+   */
+  upper_message_id: string
+}
+
+export interface ReadUser {
+  user_id_type: Lark.UserIdType
+  user_id: string
+  timestamp: string
+  tenant_key: string
+}
+
+export interface GetMessageListParams {
+  /**
+   * Currently there is only 'chat' available
+   * @see https://open.larksuite.com/document/server-docs/im-v1/message/list
+   */
+  container_id_type: 'p2p' | 'chat'
+  /**
+   * Should be in the format like `oc_234jsi43d3ssi993d43545f`
+   */
+  container_id: string
+  /** Timestamp in seconds */
+  start_time?: string | number
+  /** Timestamp in seconds */
+  end_time?: string | number
+  /** @default 'ByCreateTimeAsc' */
+  sort_type?: 'ByCreateTimeAsc' | 'ByCreateTimeDesc'
+  /** Range from 1 to 50 */
+  page_size?: number
+  /**
+   * If the current page is the first page, this field should be omitted.
+   * Otherwise you could use the `page_token` from the previous response to
+   * get the next page.
+   */
+  page_token?: string
+}
+
+declare module '../internal' {
+  export interface Internal {
+    /** @see https://open.larksuite.com/document/uAjLw4CM/ukTMukTMukTM/reference/im-v1/message/create */
+    sendMessage(receive_id_type: Lark.ReceiveIdType, message: MessagePayload): Promise<BaseResponse & { data: Message }>
+    /** @see https://open.larksuite.com/document/uAjLw4CM/ukTMukTMukTM/reference/im-v1/message/reply */
+    replyMessage(message_id: string, message: MessagePayload): Promise<BaseResponse & { data: Message }>
+    /** @see https://open.larksuite.com/document/uAjLw4CM/ukTMukTMukTM/reference/im-v1/message/update */
+    updateMessage(message_id: string, message: Omit<MessagePayload, 'receive_id'>): Promise<BaseResponse & { data: Message }>
+    /** @see https://open.larksuite.com/document/uAjLw4CM/ukTMukTMukTM/reference/im-v1/message/get */
+    getMessage(message_id: string): Promise<BaseResponse & { data: Message }>
+    /** @see https://open.larksuite.com/document/uAjLw4CM/ukTMukTMukTM/reference/im-v1/message/delete */
+    deleteMessage(message_id: string): Promise<BaseResponse>
+    /** @see https://open.larksuite.com/document/uAjLw4CM/ukTMukTMukTM/reference/im-v1/message/read_users */
+    getMessageReadUsers(message_id: string, params: Pagination<{ user_id_type: Lark.UserIdType }>): Promise<BaseResponse & { data: Paginated<ReadUser> }>
+    /** @see https://open.larksuite.com/document/server-docs/im-v1/message/list */
+    getMessageList(params: GetMessageListParams): Promise<BaseResponse & { data: Paginated<Message> }>
+  }
+}
+
+Internal.define({
+  '/im/v1/messages': {
+    GET: 'getMessageList',
+  },
+  '/im/v1/messages?receive_id_type={receive_id_type}': {
+    POST: 'sendMessage',
+  },
+  '/im/v1/messages/{message_id}/reply': {
+    POST: 'replyMessage',
+  },
+  '/im/v1/messages/{message_id}': {
+    GET: 'getMessage',
+    PUT: 'updateMessage',
+    DELETE: 'deleteMessage',
+  },
+  '/im/v1/messages/{message_id}/read_users': {
+    GET: 'getMessageReadUsers',
+  },
+})

package/src/types/user.ts

@@ -0,0 +1,91 @@
+import { Lark } from '.'
+import { Internal } from './internal'
+
+declare module '.' {
+  export namespace Lark {
+    export interface User {
+      union_id: string
+      user_id?: string
+      open_id: string
+      name?: string
+      en_name?: string
+      nickname?: string
+      email?: string
+      mobile?: string
+      mobile_visible: boolean
+      gender?: Gender
+      avatar?: AvatarInfo
+      status?: UserStatus
+      department_ids?: string[]
+      leader_user_id?: string
+      city?: string
+      country?: string
+      work_station?: string
+      join_time?: number
+      is_tenant_manager?: boolean
+      employee_no?: string
+      employee_type?: number
+      orders?: UserOrder[]
+      custom_attrs?: any // TODO
+      enterprise_email?: string
+      job_title?: string
+      geo?: string
+      job_level_id?: string
+      job_family_id?: string
+      assign_info?: any // TODO
+      department_path?: DepartmentDetail[]
+    }
+
+    export enum Gender {
+      SECRET = 0,
+      MALE = 1,
+      FEMALE = 2,
+    }
+
+    export interface AvatarInfo {
+      avatar_72: string
+      avatar_240: string
+      avatar_640: string
+      avatar_origin: string
+    }
+
+    export interface UserStatus {
+      is_frozen: boolean
+      is_resigned: boolean
+      is_activated: boolean
+      is_exited: boolean
+      is_unjoin: boolean
+    }
+
+    export interface UserOrder {
+      department_id: string
+      user_order: number
+      department_order: number
+      is_primary_dept: boolean
+    }
+
+    export interface DepartmentDetail {
+      dotted_line_leader_user_ids: string[]
+    }
+  }
+}
+
+export interface GuildMember {
+  member_id_type: Lark.UserIdType
+  member_id: string
+  name: string
+  tenant_key: string
+}
+
+declare module './internal' {
+  export interface Internal {
+    /** @see https://open.larksuite.com/document/server-docs/contact-v3/user/get */
+    getUserInfo(user_id: string, user_id_type?: Lark.UserIdType, department_id_type?: Lark.DepartmentIdType): Promise<BaseResponse & { data: Lark.User }>
+  }
+}
+
+Internal.define({
+  'contact/v3/users/{user_id}': {
+    GET: 'getUserInfo',
+  },
+})

package/src/types/utils.ts

@@ -0,0 +1,7 @@
+export type Pagination<T> = T & { page_size?: number; page_token?: string }
+
+export interface Paginated<T> {
+  items: T[]
+  has_more: boolean
+  page_token: string
+}

package/src/utils.ts

@@ -0,0 +1,199 @@
+import crypto from 'crypto'
+import { Channel, Guild, Message, User } from '@satorijs/protocol'
+import { Context, h, Session, trimSlash } from '@satorijs/satori'
+import { FeishuBot, LarkBot } from './bot'
+import { AllEvents, Events, Lark, Message as LarkMessage, MessageContentType, MessageType } from './types'
+
+export type Sender =
+  | {
+      sender_id: Lark.UserIds
+      sender_type?: string
+      tenant_key: string
+    }
+  | (Lark.UserIdentifiers & { sender_type?: string; tenant_key: string })
+
+export function adaptSender(sender: Sender, session: Session): Session {
+  let userId: string | undefined
+  if ('sender_id' in sender) {
+    userId = sender.sender_id.open_id
+  } else {
+    userId = sender.id
+  }
+  session.userId = userId
+  return session
+}
+
+export function adaptMessage(bot: FeishuBot, data: Events['im.message.receive_v1']['event'], session: Session): Session {
+  const json = JSON.parse(data.message.content) as MessageContentType<MessageType>
+  const assetEndpoint = trimSlash(bot.config.selfUrl ?? bot.ctx.router.config.selfUrl) + bot.config.path + '/assets'
+  const content: (string | h)[] = []
+  switch (data.message.message_type) {
+    case 'text': {
+      const text = json.text as string
+      if (!data.message.mentions?.length) {
+        content.push(text)
+        break
+      }
+
+      // Lark's `at` Element would be `@user_id` in text
+      text.split(' ').forEach((word) => {
+        if (word.startsWith('@')) {
+          const mention = data.message.mentions.find((mention) => mention.key === word)
+          content.push(h.at(mention.id.open_id, { name: mention.name }))
+        } else {
+          content.push(word)
+        }
+      })
+      break
+    }
+    case 'image':
+      content.push(h.image(`${assetEndpoint}/image/${data.message.message_id}/${json.image_key}?self_id=${bot.selfId}`))
+      break
+    case 'audio':
+      content.push(h.audio(`${assetEndpoint}/file/${data.message.message_id}/${json.file_key}?self_id=${bot.selfId}`))
+      break
+    case 'media':
+      content.push(h.video(`${assetEndpoint}/file/${data.message.message_id}/${json.file_key}?self_id=${bot.selfId}`, json.image_key))
+      break
+    case 'file':
+      content.push(h.file(`${assetEndpoint}/file/${data.message.message_id}/${json.file_key}?self_id=${bot.selfId}`))
+      break
+  }
+
+  session.timestamp = +data.message.create_time
+  session.messageId = data.message.message_id
+  session.channelId = data.message.chat_id
+  session.content = content.map((c) => c.toString()).join(' ')
+
+  return session
+}
+
+export function adaptSession<C extends Context>(bot: FeishuBot<C>, body: AllEvents) {
+  const session = bot.session()
+  session.setInternal('lark', body)
+
+  switch (body.type) {
+    case 'im.message.receive_v1':
+      session.type = 'message'
+      session.subtype = body.event.message.chat_type
+      if (session.subtype === 'p2p') session.subtype = 'private'
+      session.isDirect = session.subtype === 'private'
+      adaptSender(body.event.sender, session)
+      adaptMessage(bot, body.event, session)
+      break
+  }
+  return session
+}
+
+// TODO: This function has many duplicated code with `adaptMessage`, should refactor them
+export async function decodeMessage(bot: LarkBot, body: LarkMessage): Promise<Message> {
+  const json = JSON.parse(body.body.content) as MessageContentType<MessageType>
+  const assetEndpoint = trimSlash(bot.config.selfUrl ?? bot.ctx.router.config.selfUrl) + bot.config.path + '/assets'
+  const content: h[] = []
+  switch (body.msg_type) {
+    case 'text': {
+      const text = json.text as string
+      if (!body.mentions?.length) {
+        content.push(h.text(text))
+        break
+      }
+
+      // Lark's `at` Element would be `@user_id` in text
+      text.split(' ').forEach((word) => {
+        if (word.startsWith('@')) {
+          const mention = body.mentions.find((mention) => mention.key === word)
+          content.push(h.at(mention.id, { name: mention.name }))
+        } else {
+          content.push(h.text(word))
+        }
+      })
+      break
+    }
+    case 'image':
+      content.push(h.image(`${assetEndpoint}/image/${body.message_id}/${json.image_key}?self_id=${bot.selfId}`))
+      break
+    case 'audio':
+      content.push(h.audio(`${assetEndpoint}/file/${body.message_id}/${json.file_key}?self_id=${bot.selfId}`))
+      break
+    case 'media':
+      content.push(h.video(`${assetEndpoint}/file/${body.message_id}/${json.file_key}?self_id=${bot.selfId}`, json.image_key))
+      break
+    case 'file':
+      content.push(h.file(`${assetEndpoint}/file/${body.message_id}/${json.file_key}?self_id=${bot.selfId}`))
+      break
+  }
+
+  return {
+    timestamp: +body.update_time,
+    createdAt: +body.create_time,
+    updatedAt: +body.update_time,
+    id: body.message_id,
+    content: content.map((c) => c.toString()).join(' '),
+    elements: content,
+    quote: body.upper_message_id ? await bot.getMessage(body.chat_id, body.upper_message_id) : undefined,
+  }
+}
+
+/**
+ * Get ID type from id string
+ * @see https://open.larksuite.com/document/home/user-identity-introduction/introduction
+ */
+export function extractIdType(id: string): Lark.ReceiveIdType {
+  if (id.startsWith('ou')) return 'open_id'
+  if (id.startsWith('on')) return 'union_id'
+  if (id.startsWith('oc')) return 'chat_id'
+  if (id.includes('@')) return 'email'
+  return 'user_id'
+}
+
+export function decodeChannel(guild: Lark.Guild): Channel {
+  return {
+    id: guild.chat_id,
+    type: Channel.Type.TEXT,
+    name: guild.name,
+    parentId: guild.chat_id,
+  }
+}
+
+export function decodeGuild(guild: Lark.Guild): Guild {
+  return {
+    id: guild.chat_id,
+    name: guild.name,
+    avatar: guild.avatar,
+  }
+}
+
+export function decodeUser(user: Lark.User): User {
+  return {
+    id: user.open_id,
+    avatar: user.avatar?.avatar_origin,
+    isBot: false,
+    name: user.name,
+  }
+}
+
+export class Cipher {
+  encryptKey: string
+  key: Buffer
+
+  constructor(key: string) {
+    this.encryptKey = key
+    const hash = crypto.createHash('sha256')
+    hash.update(key)
+    this.key = hash.digest()
+  }
+
+  decrypt(encrypt: string) {
+    const encryptBuffer = Buffer.from(encrypt, 'base64')
+    const decipher = crypto.createDecipheriv('aes-256-cbc', this.key, encryptBuffer.slice(0, 16))
+    let decrypted = decipher.update(encryptBuffer.slice(16).toString('hex'), 'hex', 'utf8')
+    decrypted += decipher.final('utf8')
+    return decrypted
+  }
+
+  calculateSignature(timestamp: string, nonce: string, body: string): string {
+    const content = timestamp + nonce + this.encryptKey + body
+    const sign = crypto.createHash('sha256').update(content).digest('hex')
+    return sign
+  }
+}