@lark-base-open/base-database-cli 1.1.1 → 1.3.8

package/templates/database-starter/page/src/lib/database-runtime-attachment.test.ts

@@ -2,10 +2,11 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 const getRuntimeContext = vi.fn()
 const siteRuntimeFetch = vi.fn()
+const invokeHttp = vi.fn()
 
 vi.mock('@lark-base-open/base-site-channel/runtime', () => ({
   fetch: siteRuntimeFetch,
-  invokeHttp: vi.fn(),
+  invokeHttp,
   siteRuntime: { getRuntimeContext },
 }))
 
@@ -25,6 +26,7 @@ async function loadDatabaseRuntime() {
 beforeEach(() => {
   getRuntimeContext.mockReset()
   siteRuntimeFetch.mockReset()
+  invokeHttp.mockReset()
   vi.stubGlobal('location', {
     ancestorOrigins: ['https://ancestor.example'],
     pathname: '/app/pathToken/',
@@ -38,89 +40,109 @@ afterEach(() => {
   vi.unstubAllGlobals()
 })
 
-describe('buildAttachmentCoverUrl', () => {
-  it('uses the ancestor origin before the referrer', async () => {
-    getRuntimeContext.mockResolvedValue({ siteToken: 'hostToken' })
-
-    const { buildAttachmentCoverUrl, resolveDatabaseContext } =
-      await loadDatabaseRuntime()
-    const context = await resolveDatabaseContext()
-
-    expect(buildAttachmentCoverUrl(context, attachmentRef)).toMatch(
-      /^https:\/\/ancestor\.example\/space\/api\/box\/stream\/download\/v2\/cover\//,
+describe('fetchAttachmentCover', () => {
+  it('builds an HTTP binary request with trusted runtime context and full coordinates', async () => {
+    getRuntimeContext.mockResolvedValue({ siteToken: 'siteToken', env: 'prod' })
+    invokeHttp.mockResolvedValue(
+      new Response(new Uint8Array([0, 128, 255]), {
+        headers: { 'content-type': 'image/png' },
+      }),
     )
-  })
-
-  it('falls back to the referrer origin when ancestorOrigins is unavailable', async () => {
-    vi.stubGlobal('location', { pathname: '/app/pathToken/' })
-    getRuntimeContext.mockResolvedValue({ siteToken: 'hostToken' })
-
-    const { buildAttachmentCoverUrl, resolveDatabaseContext } =
-      await loadDatabaseRuntime()
-    const context = await resolveDatabaseContext()
-
-    expect(buildAttachmentCoverUrl(context, attachmentRef)).toMatch(
-      /^https:\/\/referrer\.example\/space\/api\/box\/stream\/download\/v2\/cover\//,
+    const controller = new AbortController()
+    const { fetchAttachmentCover } = await loadDatabaseRuntime()
+    const blob = await fetchAttachmentCover(attachmentRef, 480, {
+      signal: controller.signal,
+    })
+    expect(new Uint8Array(await blob.arrayBuffer())).toEqual(
+      new Uint8Array([0, 128, 255]),
     )
-  })
-
-  it('snaps the requested size up and defaults to 360', async () => {
-    getRuntimeContext.mockResolvedValue({})
-    const { buildAttachmentCoverUrl } = await loadDatabaseRuntime()
-    const context = {
-      env: 'prod',
-      gatewayOrigin: 'https://gateway.example',
-      token: 'siteToken',
-    } as const
-
-    const requested = new URL(
-      buildAttachmentCoverUrl(context, attachmentRef, 480),
+    const request = invokeHttp.mock.calls[0][0]
+    expect(request.init).toEqual({
+      method: 'GET',
+      responseType: 'arrayBuffer',
+      timeoutMs: 45000,
+    })
+    expect(request.signal).toBe(controller.signal)
+    const url = new URL(request.url, 'https://host.example')
+    expect(url.pathname).toBe(
+      '/space/api/box/stream/download/v2/cover/boxcnFileToken',
     )
-    const defaulted = new URL(buildAttachmentCoverUrl(context, attachmentRef))
-
-    expect(requested.searchParams.get('width')).toBe('720')
-    expect(requested.searchParams.get('height')).toBe('720')
-    expect(defaulted.searchParams.get('width')).toBe('360')
-    expect(defaulted.searchParams.get('height')).toBe('360')
+    expect(url.searchParams.get('width')).toBe('720')
+    expect(JSON.parse(url.searchParams.get('extra')!)).toEqual({
+      bitablePerm: {
+        siteToken: 'siteToken',
+        siteEnv: 'prod',
+        tableId: 'tblTickets',
+        attachments: { fldPhotos: { recTicket: ['boxcnFileToken'] } },
+      },
+    })
   })
-
-  it('returns an empty string when the gateway origin is missing', async () => {
-    getRuntimeContext.mockResolvedValue({})
-    const { buildAttachmentCoverUrl } = await loadDatabaseRuntime()
-
-    expect(
-      buildAttachmentCoverUrl(
-        { env: 'prod', gatewayOrigin: '', token: 'siteToken' },
-        attachmentRef,
-      ),
-    ).toBe('')
+  it.each([401, 403])(
+    'reports HTTP %i with LogID without retry',
+    async (status) => {
+      invokeHttp.mockResolvedValue(
+        new Response('denied', {
+          status,
+          headers: { 'x-tt-logid': 'test-log' },
+        }),
+      )
+      const { fetchAttachmentCover } = await loadDatabaseRuntime()
+      await expect(fetchAttachmentCover(attachmentRef)).rejects.toThrow(
+        `HTTP ${status}, LogID test-log`,
+      )
+      expect(invokeHttp).toHaveBeenCalledTimes(1)
+    },
+  )
+  it('rejects non-image and empty responses', async () => {
+    const { fetchAttachmentCover } = await loadDatabaseRuntime()
+    for (const response of [
+      new Response('html'),
+      new Response('', { headers: { 'content-type': 'image/png' } }),
+    ]) {
+      invokeHttp.mockResolvedValue(response)
+      await expect(fetchAttachmentCover(attachmentRef)).rejects.toThrow(
+        'The host did not return a valid image',
+      )
+    }
   })
-
-  it('puts the complete attachment location and site token in extra', async () => {
-    getRuntimeContext.mockResolvedValue({})
-    const { buildAttachmentCoverUrl } = await loadDatabaseRuntime()
-    const url = new URL(
-      buildAttachmentCoverUrl(
-        {
-          env: 'prod',
-          gatewayOrigin: 'https://gateway.example',
-          token: 'siteToken',
-        },
-        attachmentRef,
-      ),
+  it('shows an English error while preserving host bridge details as the cause', async () => {
+    const failure = { code: 'REQUEST_TIMEOUT', msg: 'HTTP 请求超时' }
+    invokeHttp.mockRejectedValue(failure)
+    const { fetchAttachmentCover } = await loadDatabaseRuntime()
+    await expect(fetchAttachmentCover(attachmentRef)).rejects.toMatchObject({
+      message: 'Attachment image request timed out (code REQUEST_TIMEOUT)',
+      code: 'REQUEST_TIMEOUT',
+      cause: failure,
+    })
+    await expect(fetchAttachmentCover(attachmentRef)).rejects.toBeInstanceOf(
+      Error,
     )
-    const extra = JSON.parse(String(url.searchParams.get('extra'))) as unknown
-
-    expect(extra).toEqual({
-      bitablePerm: {
-        tableId: 'tblTickets',
-        attachments: {
-          fldPhotos: { recTicket: ['boxcnFileToken'] },
-        },
-        baseAppToken: 'siteToken',
+  })
+  it('preserves SDK errors and recognizes Channel timeout replies', async () => {
+    const sdkError = Object.assign(
+      new Error('当前宿主不支持 HTTP 二进制响应，请升级宿主'),
+      {
+        name: 'SiteRuntimeInvocationError',
+        code: 'HTTP_RESPONSE_TYPE_UNSUPPORTED',
       },
+    )
+    invokeHttp.mockRejectedValue(sdkError)
+    const { fetchAttachmentCover } = await loadDatabaseRuntime()
+    await expect(fetchAttachmentCover(attachmentRef)).rejects.toBe(sdkError)
+
+    invokeHttp.mockRejectedValue({ code: 10005, msg: '超时' })
+    await expect(fetchAttachmentCover(attachmentRef)).rejects.toMatchObject({
+      message: 'Attachment image request timed out (code 10005)',
+      code: '10005',
     })
   })
+  it('does not request an already canceled image', async () => {
+    const { fetchAttachmentCover } = await loadDatabaseRuntime()
+    await expect(
+      fetchAttachmentCover(attachmentRef, 360, { signal: AbortSignal.abort() }),
+    ).rejects.toMatchObject({ name: 'AbortError' })
+    expect(invokeHttp).not.toHaveBeenCalled()
+  })
 })
 
 describe('fetchAttachmentDownloadUrl', () => {
@@ -130,6 +152,7 @@ describe('fetchAttachmentDownloadUrl', () => {
       siteRuntimeFetch.mockResolvedValue({
         json: () =>
           Promise.resolve({
+            code: 0,
             data: { url: 'https://download.example/authcode/?code=signed' },
           }),
         ok: true,
@@ -161,11 +184,92 @@ describe('fetchAttachmentDownloadUrl', () => {
             attachments: {
               fldPhotos: { recTicket: ['boxcnFileToken'] },
             },
-            baseAppToken: 'siteToken',
+            siteToken: 'siteToken',
+            siteEnv: 'prod',
           },
         }),
         file_token: 'boxcnFileToken',
       })
     },
   )
+
+  it.each([200, 403])(
+    'reports the business error before checking data.url for HTTP %i',
+    async (status) => {
+      const body = { code: 800008201, msg: '对外返回' }
+      siteRuntimeFetch.mockResolvedValue(
+        new Response(JSON.stringify(body), {
+          status,
+          headers: { 'x-tt-logid': 'attachment-log' },
+        }),
+      )
+      const { fetchAttachmentDownloadUrl } = await loadDatabaseRuntime()
+
+      await expect(
+        fetchAttachmentDownloadUrl(
+          { env: 'prod', gatewayOrigin: '', token: 'siteToken' },
+          attachmentRef,
+        ),
+      ).rejects.toMatchObject({
+        code: '800008201',
+        cause: body,
+        message:
+          'Attachment service could not provide a download URL (code 800008201, LogID attachment-log)',
+      })
+    },
+  )
+
+  it('reports malformed successful responses without claiming the URL alone is missing', async () => {
+    siteRuntimeFetch.mockResolvedValue(
+      new Response('not JSON', {
+        status: 200,
+        headers: { 'x-tt-logid': 'invalid-json-log' },
+      }),
+    )
+    const { fetchAttachmentDownloadUrl } = await loadDatabaseRuntime()
+
+    await expect(
+      fetchAttachmentDownloadUrl(
+        { env: 'prod', gatewayOrigin: '', token: 'siteToken' },
+        attachmentRef,
+      ),
+    ).rejects.toThrow(
+      'Attachment download URL response is not valid JSON, LogID invalid-json-log',
+    )
+  })
+
+  it('includes the gateway LogID when a successful response lacks data.url', async () => {
+    siteRuntimeFetch.mockResolvedValue(
+      new Response(JSON.stringify({ code: 0, data: {} }), {
+        status: 200,
+        headers: { 'x-tt-logid': 'missing-url-log' },
+      }),
+    )
+    const { fetchAttachmentDownloadUrl } = await loadDatabaseRuntime()
+    await expect(
+      fetchAttachmentDownloadUrl(
+        { env: 'prod', gatewayOrigin: '', token: 'siteToken' },
+        attachmentRef,
+      ),
+    ).rejects.toThrow(
+      'Attachment download URL response is missing data.url, LogID missing-url-log',
+    )
+  })
+
+  it('does not surface a host bridge message that may be untranslated', async () => {
+    const failure = { code: 'REQUEST_TIMEOUT', msg: 'HTTP 请求超时' }
+    siteRuntimeFetch.mockRejectedValue(failure)
+    const { fetchAttachmentDownloadUrl } = await loadDatabaseRuntime()
+
+    await expect(
+      fetchAttachmentDownloadUrl(
+        { env: 'prod', gatewayOrigin: '', token: 'siteToken' },
+        attachmentRef,
+      ),
+    ).rejects.toMatchObject({
+      message:
+        'Attachment download URL request timed out (code REQUEST_TIMEOUT)',
+      cause: failure,
+    })
+  })
 })

package/templates/database-starter/page/src/lib/database-runtime.test.ts

@@ -2,7 +2,10 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
 import {
   buildDatabaseInvokeFunctionPath,
   buildDatabaseInvokeGetPath,
+  getSiteAIFunctionTask,
   getDatabaseContext,
+  hasRunnableMediaTask,
+  normalizeSiteAIMediaTask,
 } from './database-runtime'
 
 function stubPathname(pathname: string): void {
@@ -43,21 +46,23 @@ describe('getDatabaseContext', () => {
 })
 
 describe('buildDatabaseInvokeGetPath', () => {
-  it('builds the prod path with the chatbot flag', () => {
+  it('builds the prod metadata path', () => {
     expect(
-      buildDatabaseInvokeGetPath(
-        { env: 'prod', gatewayOrigin: '', token: 'bascnDemo' },
-        true,
-      ),
-    ).toBe('/space/api/bitable/site/v1/bascnDemo/invoke_get?withChatbot=true')
+      buildDatabaseInvokeGetPath({
+        env: 'prod',
+        gatewayOrigin: '',
+        token: 'bascnDemo',
+      }),
+    ).toBe('/space/api/bitable/site/v1/bascnDemo/invoke_get')
   })
 
   it('adds the preview env for draft artifacts', () => {
     expect(
-      buildDatabaseInvokeGetPath(
-        { env: 'preview', gatewayOrigin: '', token: 'bascnDemo' },
-        false,
-      ),
+      buildDatabaseInvokeGetPath({
+        env: 'preview',
+        gatewayOrigin: '',
+        token: 'bascnDemo',
+      }),
     ).toBe('/space/api/bitable/site/v1/bascnDemo/invoke_get?env=preview')
   })
 })
@@ -101,3 +106,118 @@ describe('buildDatabaseInvokeFunctionPath', () => {
     )
   })
 })
+
+describe('normalizeSiteAIMediaTask', () => {
+  it('unwraps the common OpenAPI response envelope', () => {
+    expect(
+      normalizeSiteAIMediaTask({
+        code: 0,
+        data: {
+          capability_type: 'image',
+          request_id: 'req-create',
+          status: 'queued',
+          task_id: 'task-1',
+          type: 'image_task',
+        },
+        msg: 'success',
+      }),
+    ).toEqual({
+      capabilityType: 'image',
+      requestId: 'req-create',
+      status: 'queued',
+      taskId: 'task-1',
+      type: 'image_task',
+    })
+  })
+
+  it('surfaces OpenAPI business errors instead of returning an empty task', () => {
+    expect(() =>
+      normalizeSiteAIMediaTask({
+        code: 800008006,
+        data: null,
+        msg: 'record sink field mapping is invalid',
+      }),
+    ).toThrow('record sink field mapping is invalid')
+  })
+
+  it('surfaces thrift-style BaseResp business errors', () => {
+    expect(() =>
+      normalizeSiteAIMediaTask({
+        BaseResp: {
+          StatusCode: 800008006,
+          StatusMessage: 'record sink field mapping is invalid',
+        },
+      }),
+    ).toThrow('record sink field mapping is invalid')
+  })
+
+  it('normalizes thrift-style task field names', () => {
+    expect(
+      normalizeSiteAIMediaTask({
+        BaseResp: { StatusCode: 0, StatusMessage: 'success' },
+        CapabilityType: 'image',
+        ImageAssets: [
+          {
+            SafetyStatus: 'pass',
+            Token: 'token-1',
+            URL: 'https://example.com/image.png',
+          },
+        ],
+        Progress: 100,
+        RequestID: 'req-get',
+        Status: 'succeeded',
+        TaskID: 'task-1',
+        Type: 'image_task',
+      }),
+    ).toEqual({
+      capabilityType: 'image',
+      imageAssets: [
+        {
+          safetyStatus: 'pass',
+          token: 'token-1',
+          url: 'https://example.com/image.png',
+        },
+      ],
+      progress: 100,
+      requestId: 'req-get',
+      status: 'succeeded',
+      taskId: 'task-1',
+      type: 'image_task',
+    })
+  })
+
+  it('rejects a successful response without a taskId', () => {
+    expect(() =>
+      normalizeSiteAIMediaTask({
+        code: 0,
+        data: { requestId: 'req-create', status: 'queued', type: 'image_task' },
+        msg: 'success',
+      }),
+    ).toThrow('AI Function task response has an invalid structure')
+  })
+
+  it('only treats queued and running tasks with a taskId as pollable', () => {
+    expect(
+      hasRunnableMediaTask({
+        requestId: 'req-create',
+        status: 'queued',
+        taskId: 'task-1',
+        type: 'image_task',
+      }),
+    ).toBe(true)
+    expect(
+      hasRunnableMediaTask({
+        requestId: 'req-create',
+        status: 'queued',
+        taskId: '',
+        type: 'image_task',
+      }),
+    ).toBe(false)
+  })
+
+  it('rejects polling before transport when taskId is empty', async () => {
+    await expect(getSiteAIFunctionTask('image', '')).rejects.toThrow(
+      'AI Function task ID must not be empty',
+    )
+  })
+})