@open-dy/vibecoding-sdk-taro 0.0.1-beta.5 → 0.0.1

package/src/runtime/douyin-login-request.ts

@@ -0,0 +1,514 @@
+import Taro from '@tarojs/taro'
+import { appendGetQuery, createUrl } from './network-url'
+
+type DouyinLoginAuth = {
+  accessToken: string
+  openId: string
+  expiresAt: number
+}
+
+type DouyinCode2TokenResponse = {
+  access_token?: string
+  open_id?: string
+  expire_in?: number
+  base_resp?: {
+    status_code?: number
+    status_message?: string
+  }
+}
+
+const DOUYIN_LOGIN_EXPIRE_BUFFER_MS = 5 * 60 * 1000
+
+let platformChannel: '' | 'ext' = ''
+
+export const setDouyinLoginPlatformChannel = (channel: '' | 'ext') => {
+  platformChannel = channel
+}
+
+const ttRuntime: DouyinMiniProgramRuntime | undefined =
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  typeof tt !== 'undefined' ? tt : undefined
+
+let cachedLoginAuth: DouyinLoginAuth | null = null
+let pendingLoginAuthPromise: Promise<DouyinLoginAuth> | null = null
+
+const getHeaderValueIgnoreCase = (
+  header: Record<string, unknown> | undefined,
+  key: string,
+): string => {
+  if (!header) {
+    return ''
+  }
+
+  const matchedKey = Object.keys(header).find(
+    currentKey => currentKey.toLowerCase() === key.toLowerCase(),
+  )
+  if (!matchedKey) {
+    return ''
+  }
+
+  const value = header[matchedKey]
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+const isLoginAuthValid = (auth: DouyinLoginAuth | null): auth is DouyinLoginAuth => {
+  return Boolean(auth && auth.expiresAt > Date.now())
+}
+
+export const mergeCachedDouyinLoginHeaders = (
+  header?: Record<string, unknown>,
+): Record<string, unknown> | undefined => {
+  const auth = cachedLoginAuth
+  if (isLoginAuthValid(auth)) {
+    return {
+      ...header,
+      OpenId: auth.openId,
+      Authorization: `Bearer ${auth.accessToken}`,
+    }
+  }
+
+  return header
+}
+
+const persistLoginAuth = (auth: DouyinLoginAuth) => {
+  cachedLoginAuth = auth
+}
+
+/**
+ * @desc 清除普通小程序缓存的抖音登录凭证。
+ * @params 无参数。
+ * @return {void} 清除本地登录缓存。
+ * @example clearDouyinLoginAuth()
+ */
+export const clearDouyinLoginAuth = () => {
+  cachedLoginAuth = null
+  pendingLoginAuthPromise = null
+}
+
+const loginByDouyinRuntime = () =>
+  new Promise<string>((resolve, reject) => {
+    if (!ttRuntime?.login) {
+      reject(new Error('tt.login is unavailable'))
+      return
+    }
+
+    ttRuntime.login({
+      success: result => {
+        if (!result.code) {
+          reject(new Error(result.errMsg || 'tt.login returned empty code'))
+          return
+        }
+        resolve(result.code)
+      },
+      fail: result => {
+        reject(new Error(result.errMsg || 'tt.login failed'))
+      },
+    })
+  })
+
+const fetchLoginAuthByCode = async (code: string): Promise<DouyinLoginAuth> => {
+  const response = await new Promise<Taro.request.SuccessCallbackResult<DouyinCode2TokenResponse>>(
+    (resolve, reject) => {
+      // eslint-disable-next-line
+      Taro.request<DouyinCode2TokenResponse>({
+        url: createUrl('/dy_code2token'),
+        method: 'POST',
+        header: {
+          'Content-Type': 'application/json',
+          ...(platformChannel === 'ext'
+            ? { 'ai-platform-channel': 'ext' }
+            : {}),
+        },
+        data: { code },
+        success: resolve,
+        fail: reject,
+      })
+    },
+  )
+
+  const result = response.data || {}
+  const statusCode = result.base_resp?.status_code ?? -1
+  const statusMessage = result.base_resp?.status_message || 'dy_code2token failed'
+  const responseHeader = response.header as Record<string, unknown> | undefined
+  const ttLogId = getHeaderValueIgnoreCase(
+    responseHeader,
+    'x-tt-logid',
+  )
+  const ttEnv = getHeaderValueIgnoreCase(responseHeader, 'x-tt-env')
+
+  if (
+    statusCode !== 0 ||
+    !result.access_token ||
+    !result.open_id ||
+    !result.expire_in
+  ) {
+    const extraMessages = [
+      ttLogId ? `x-tt-logid: ${ttLogId}` : '',
+      ttEnv ? `x-tt-env: ${ttEnv}` : '',
+    ].filter(Boolean)
+    const errorMessage = extraMessages.length > 0
+      ? `${statusMessage} (${extraMessages.join(', ')})`
+      : statusMessage
+    console.error('[dy_code2token] request failed:', errorMessage, result)
+    throw new Error(errorMessage)
+  }
+
+  const expireInMs = result.expire_in * 1000
+  const expiresAt =
+    Date.now() + Math.max(expireInMs - DOUYIN_LOGIN_EXPIRE_BUFFER_MS, 60 * 1000)
+
+  return {
+    accessToken: result.access_token,
+    openId: result.open_id,
+    expiresAt,
+  }
+}
+
+const getDouyinLoginAuth = async (): Promise<DouyinLoginAuth> => {
+  const currentLoginAuth = cachedLoginAuth ?? null
+  if (isLoginAuthValid(currentLoginAuth)) {
+    return currentLoginAuth
+  }
+
+  if (pendingLoginAuthPromise) {
+    return pendingLoginAuthPromise
+  }
+
+  pendingLoginAuthPromise = (async () => {
+    const code = await loginByDouyinRuntime()
+    const auth = await fetchLoginAuthByCode(code)
+    persistLoginAuth(auth)
+    return auth
+  })()
+
+  try {
+    return await pendingLoginAuthPromise
+  } finally {
+    pendingLoginAuthPromise = null
+  }
+}
+
+const createLoginHeaders = async (header?: Record<string, unknown>) => {
+  try {
+    const auth = await getDouyinLoginAuth()
+    return {
+      ...header,
+      OpenId: auth.openId,
+      Authorization: `Bearer ${auth.accessToken}`,
+    }
+  } catch(err) {
+    return header
+  }
+}
+
+const createRequestHeaders = async (
+  header?: Record<string, unknown>,
+): Promise<Record<string, unknown> | undefined> => {
+  try {
+    const cachedHeader = mergeCachedDouyinLoginHeaders(header)
+    if (cachedHeader !== header) {
+      return cachedHeader
+    }
+
+    return createLoginHeaders(header)
+  } catch(err) {
+    return header
+  }
+}
+
+export const requestByDouyinLogin = (
+  option: Taro.request.Option<any, any>,
+): ReturnType<typeof Taro.request> => {
+  const requestPromise = (async (): Promise<Taro.request.SuccessCallbackResult<any>> => {
+    const method = option.method ?? 'GET'
+    const header = await createRequestHeaders(option.header)
+    const { url, data, ...rest } = option
+
+    return new Promise<Taro.request.SuccessCallbackResult<any>>((resolve, reject) => {
+      // eslint-disable-next-line
+      Taro.request({
+        ...rest,
+        url: appendGetQuery(
+          createUrl(url),
+          data as Record<string, any> | undefined,
+          method,
+        ),
+        method,
+        header,
+        ...(method.toUpperCase() === 'GET' ? {} : { data }),
+        success: result => {
+          option.success?.(result)
+          option.complete?.(result)
+          resolve(result)
+        },
+        fail: result => {
+          option.fail?.(result as never)
+          option.complete?.(result as never)
+          reject(result)
+        },
+      })
+    })
+  })()
+
+  return requestPromise as ReturnType<typeof Taro.request>
+}
+
+export const requestSSEByDouyinLogin = async (
+  option: Taro.request.Option<any, any>,
+): Promise<EventSourceTask> => {
+  const method = option.method ?? "GET";
+  const header = await createRequestHeaders(option.header);
+  const { url, data } = option;
+
+  if (!ttRuntime?.createEventSource) {
+    return requestSSEByFetch({
+      url: appendGetQuery(
+        createUrl(url),
+        data as Record<string, any> | undefined,
+        method,
+      ),
+      method,
+      header,
+      ...(method.toUpperCase() === "GET" ? {} : { data }),
+    });
+  }
+
+  const eventSource = ttRuntime!.createEventSource({
+    url: appendGetQuery(
+      createUrl(url),
+      data as Record<string, any> | undefined,
+      method,
+    ),
+    method,
+    header,
+    ...(method.toUpperCase() === "GET" ? {} : { data }),
+  });
+
+  return eventSource;
+};
+
+/**
+ * 解析 SSE 缓冲区
+ */
+export function parseSseBuffer(buffer: string): { frames: string[]; rest: string } {
+  const records = buffer.split(/\n\n/);
+  const rest = records.pop() ?? '';
+  const frames = records
+    .map(record => record.split('\n').find(line => line.startsWith('data: ')))
+    .filter((line): line is string => Boolean(line))
+    .map(line => line.slice(6));
+  return { frames, rest };
+}
+
+
+/**
+ * H5 环境下使用 fetch 进行 SSE 流式请求，返回与 tt.createEventSource 一致的 EventSourceTask
+ */
+export async function requestSSEByFetch(input: {
+  url: string;
+  data?: unknown;
+  method?: string;
+  header?: Record<string, unknown>;
+}): Promise<EventSourceTask> {
+  const method = (input.method ?? "POST").toUpperCase();
+  const header = input.header;
+
+  const callbacks: {
+    open: (() => void) | null;
+    error: (() => void) | null;
+    close: (() => void) | null;
+    message: ((chunk: { data: string; id: number }) => void) | null;
+  } = {
+    open: null,
+    error: null,
+    close: null,
+    message: null,
+  };
+  const state: { readyState: 0 | 1 | 2 } = { readyState: 0 };
+  let messageId = 0;
+  const abortController =
+    typeof AbortController !== "undefined" ? new AbortController() : null;
+
+  const closeTask = (notify: boolean) => {
+    if (state.readyState === 2) {
+      return;
+    }
+    state.readyState = 2;
+    abortController?.abort();
+    if (notify) {
+      callbacks.close?.();
+    }
+  };
+
+  const task: EventSourceTask = {
+    close: () => closeTask(true),
+    onClose: (cb) => {
+      callbacks.close = cb;
+    },
+    onOpen: (cb) => {
+      callbacks.open = cb;
+    },
+    onError: (cb) => {
+      callbacks.error = cb;
+    },
+    onMessage: (cb) => {
+      callbacks.message = cb;
+    },
+    get readyState() {
+      return state.readyState;
+    },
+  };
+
+  const fetchHeaders: HeadersInit = {
+    "Content-Type": "application/json",
+    Accept: "text/event-stream",
+    ...(header as Record<string, string>),
+  };
+
+  void (async () => {
+    try {
+      // eslint-disable-next-line no-restricted-globals
+      const response = await fetch(input.url, {
+        method,
+        headers: fetchHeaders,
+        body: method === "GET" ? undefined : JSON.stringify(input.data ?? {}),
+        signal: abortController?.signal,
+      });
+
+      if (!response.ok || !response.body) {
+        state.readyState = 2;
+        callbacks.error?.();
+        callbacks.close?.();
+        return;
+      }
+
+      state.readyState = 1;
+      callbacks.open?.();
+
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+
+      try {
+        while (state.readyState === 1) {
+          const { value, done } = await reader.read();
+          if (done) break;
+
+          buffer += decoder.decode(value, { stream: true });
+          const parsed = parseSseBuffer(buffer);
+          buffer = parsed.rest;
+          parsed.frames.forEach((data) => {
+            messageId += 1;
+            callbacks.message?.({ data, id: messageId });
+          });
+        }
+
+        // 处理剩余缓冲区
+        if (buffer) {
+          const parsed = parseSseBuffer(buffer + "\n\n");
+          parsed.frames.forEach((data) => {
+            messageId += 1;
+            callbacks.message?.({ data, id: messageId });
+          });
+        }
+      } finally {
+        reader.releaseLock();
+      }
+
+      closeTask(true);
+    } catch (error) {
+      if ((state.readyState as 0 | 1 | 2) !== 2) {
+        state.readyState = 2;
+        callbacks.error?.();
+        callbacks.close?.();
+      }
+    }
+  })();
+
+  return task;
+}
+
+export function createUploadOption(option: Taro.uploadFile.Option) {
+  if (option.url.startsWith('http://') || option.url.startsWith('https://')) {
+    return option
+  }
+
+  return {
+    ...option,
+    url: UPLOAD_URL,
+    name: 'file',
+    formData: {
+      ...option.formData,
+      path: `/workspace/tmp/${(option.fileName ?? '').replace(/^\//, '')}`,
+    }
+  } as Taro.uploadFile.Option;
+}
+export async function uploadByDouyinLogin(option: Taro.uploadFile.Option, needLogin = true) {
+  const requestPromise = (async (): Promise<Taro.uploadFile.SuccessCallbackResult> => {
+  if (needLogin) {
+    const header = await createLoginHeaders(option.header)
+    option.header = header
+  }
+
+  return new Promise<Taro.uploadFile.SuccessCallbackResult>((resolve, reject) => {
+    // eslint-disable-next-line no-restricted-properties
+    Taro.uploadFile({
+      ...createUploadOption(option),
+      success: result => {
+        option.success?.(result)
+        option.complete?.(result)
+        resolve(result)
+      },
+      fail: result => {
+        option.fail?.(result as never)
+        option.complete?.(result as never)
+        reject(result)
+      },
+    })
+  })
+})()
+
+return requestPromise as ReturnType<typeof Taro.uploadFile>
+}
+
+
+export function createDownloadOption(option: Taro.downloadFile.Option) {
+  if (option.url.startsWith('http://') || option.url.startsWith('https://')) {
+    return option
+  }
+
+  return {
+    ...option,
+    url: `${DOWNLOAD_URL}/workspace/tmp/${(option.filePath ?? '').replace(/^\//, '')}`,
+    filePath: undefined, // 文件路径已经拼到url上了，不需要这个参数
+  } as Taro.downloadFile.Option;
+}
+
+export async function downloadByDouyinLogin(option: Taro.downloadFile.Option, needLogin = true) {
+  const requestPromise = (async (): Promise<Taro.downloadFile.FileSuccessCallbackResult> => {
+    if (needLogin) {
+      const header = await createLoginHeaders(option.header)
+      option.header = header
+    }
+
+    return new Promise<Taro.downloadFile.FileSuccessCallbackResult>((resolve, reject) => {
+      // eslint-disable-next-line no-restricted-properties
+      Taro.downloadFile({
+        ...createDownloadOption(option),
+        success: result => {
+          option.success?.(result)
+          option.complete?.(result)
+          resolve(result)
+        },
+        fail: result => {
+          option.fail?.(result as never)
+          option.complete?.(result as never)
+          reject(result)
+        },
+      })
+    })
+  })()
+
+  return requestPromise as ReturnType<typeof Taro.downloadFile>
+}