AI-native design editor. Open-source Figma alternative.
import { describe, expect, test } from 'bun:test'
import { CloudAPIError, createCloudAPIClient } from '#cloud/client'
import { omit } from 'es-toolkit'
const workspaceId = '11111111-1111-4111-8111-111111111111'
const documentId = '22222222-2222-4222-8222-222222222222'
const revisionId = '33333333-3333-4333-8333-333333333333'
const collaborationTicket = {
token: 'signed-token',
documentId,
roomId: `cloud:${documentId}:2`,
roomKey: 'r'.repeat(43),
principal: { kind: 'guest' as const, guestId: 'stable-guest-id-123', name: 'Guest' },
permission: 'view' as const,
roomEpoch: 2,
expiresAt: '2026-01-01T00:05:00.000Z',
serverEnforcedWrites: false as const
}
const document = {
id: documentId,
workspaceId,
name: 'Homepage',
kind: 'board' as const,
currentRevisionId: revisionId,
version: 1,
createdAt: '2026-01-01T00:00:00.000Z',
updatedAt: '2026-01-01T00:00:00.000Z'
}
describe('createCloudAPIClient', () => {
test('reads a document an older server lists without a kind as a design', async () => {
const older = omit(document, ['kind'])
const client = createCloudAPIClient('https://cloud.example.com/api', {
fetch: async () => Response.json({ documents: [older] })
})
expect((await client.listDocuments(workspaceId))[0]?.kind).toBe('design')
})
test('validates document metadata and sends authenticated requests', async () => {
const requests: Request[] = []
const client = createCloudAPIClient('https://cloud.example.com/api', {
fetch: async (input, init) => {
requests.push(new Request(input, init))
return Response.json({ documents: [document] })
}
})
expect(await client.listDocuments(workspaceId)).toEqual([document])
expect(requests[0]?.url).toBe(
`https://cloud.example.com/api/workspaces/${workspaceId}/documents`
)
expect(requests[0]?.credentials).toBe('include')
})
test('pages through the version history of a document', async () => {
const version = {
id: '44444444-4444-4444-8444-444444444444',
revisionId,
kind: 'named' as const,
name: 'Hand-off',
description: null,
createdAt: '2026-01-01T00:00:00.000Z',
createdBy: { id: 'alice', name: 'Alice' },
restoredFromVersionId: null,
current: true
}
const requests: Request[] = []
const client = createCloudAPIClient('https://cloud.example.com/api', {
fetch: async (input, init) => {
requests.push(new Request(input, init))
return Response.json({ versions: [version], nextCursor: null })
}
})
expect(
await client.listDocumentVersions(documentId, { before: version.id, limit: 20 })
).toEqual({ versions: [version], nextCursor: null })
const url = new URL(requests[0]?.url ?? '')
expect(url.pathname).toBe(`/api/documents/${documentId}/versions`)
expect(Object.fromEntries(url.searchParams)).toEqual({ before: version.id, limit: '20' })
})
test('lists documents shared with the person and rejects malformed entries', async () => {
const shared = {
...document,
workspaceName: 'Client work',
permission: 'view' as const,
sharedBy: { name: 'Alice' },
sharedAt: '2026-01-02T00:00:00.000Z'
}
let body: unknown = { documents: [shared] }
const requests: string[] = []
const client = createCloudAPIClient('https://cloud.example.com/api', {
fetch: async (input, init) => {
requests.push(new Request(input, init).url)
return Response.json(body)
}
})
expect(await client.listSharedDocuments()).toEqual([shared])
expect(requests).toEqual(['https://cloud.example.com/api/shared-documents'])
body = { documents: [{ ...shared, permission: 'owner' }] }
await expect(client.listSharedDocuments()).rejects.toThrow()
})
test('creates upload sessions and commits revisions', async () => {
const requests: Request[] = []
const client = createCloudAPIClient('https://cloud.example.com/api/', {
fetch: async (input, init) => {
const request = new Request(input, init)
requests.push(request)
if (request.url.endsWith('/uploads')) {
return Response.json({
id: '44444444-4444-4444-8444-444444444444',
upload: {
kind: 'single',
url: 'https://objects.example.com/upload',
method: 'PUT',
headers: { 'x-amz-checksum-sha256': 'checksum' },
expiresAt: '2026-01-01T00:15:00.000Z'
}
})
}
return Response.json({ document })
}
})
const upload = await client.createUpload(documentId, {
baseRevisionId: revisionId,
byteSize: 5,
checksum: 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=',
contentType: 'application/octet-stream'
})
expect(upload.upload.kind).toBe('single')
if (upload.upload.kind !== 'single') throw new Error('Expected a single upload')
expect(upload.upload.method).toBe('PUT')
expect(
await client.commitUpload(upload.id, {
checksum: 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA='
})
).toEqual(document)
expect(requests.every((request) => request.method === 'POST')).toBe(true)
})
test('looks up authorized user profiles and accepts invitations', async () => {
const invitationId = '44444444-4444-4444-8444-444444444444'
const grant = {
id: '55555555-5555-4555-8555-555555555555',
documentId,
userId: 'recipient-user',
permission: 'view' as const,
createdBy: 'owner-user',
createdAt: '2026-01-01T00:00:00.000Z',
updatedAt: '2026-01-01T00:00:00.000Z'
}
const requests: Request[] = []
const client = createCloudAPIClient('https://cloud.example.com/api', {
fetch: async (input, init) => {
const request = new Request(input, init)
requests.push(request)
if (request.url.endsWith('/users/lookup')) {
return Response.json({
user: {
id: 'recipient-user',
name: 'Recipient',
email: '[email protected]',
image: null
}
})
}
if (request.url.endsWith('/preview')) {
return Response.json({
invitation: {
kind: 'document',
documentName: 'Homepage',
inviterName: 'Alice',
permission: 'view',
expiresAt: '2026-01-08T00:00:00.000Z',
recipientHint: 're*******@example.com'
}
})
}
return Response.json({ accepted: { kind: 'document', grant } })
}
})
expect(await client.lookupUser(documentId, { email: '[email protected]' })).toEqual({
id: 'recipient-user',
name: 'Recipient',
email: '[email protected]',
image: null
})
expect(await client.previewInvitation(invitationId, { token: 't'.repeat(32) })).toMatchObject({
documentName: 'Homepage',
recipientHint: 're*******@example.com'
})
expect(await client.acceptInvitation(invitationId, { token: 't'.repeat(32) })).toEqual({
kind: 'document',
grant
})
expect(requests.map((request) => request.url)).toEqual([
`https://cloud.example.com/api/documents/${documentId}/users/lookup`,
`https://cloud.example.com/api/invitations/${invitationId}/preview`,
`https://cloud.example.com/api/invitations/${invitationId}/accept`
])
})
test('requests and validates public collaboration tickets without dropping the API prefix', async () => {
const requests: Request[] = []
const client = createCloudAPIClient('https://cloud.example.com/api', {
fetch: async (input, init) => {
requests.push(new Request(input, init))
return Response.json({ ticket: collaborationTicket })
}
})
expect(
await client.getSharedCollaborationTicket('share-id', {
secret: 'x'.repeat(32),
guestName: 'Guest',
guestId: 'stable-guest-id-123'
})
).toEqual(collaborationTicket)
expect(requests[0]?.url).toBe(
'https://cloud.example.com/api/shares/share-id/collaboration-ticket'
)
expect(requests[0]?.credentials).toBe('include')
})
test('preserves stable API error codes', async () => {
const client = createCloudAPIClient('https://cloud.example.com/api', {
fetch: async () => Response.json({ error: { code: 'revision_conflict' } }, { status: 409 })
})
const error = await client.listDocuments(workspaceId).catch((caught: unknown) => caught)
expect(error).toBeInstanceOf(CloudAPIError)
expect(error).toMatchObject({ status: 409, code: 'revision_conflict' })
})
})