AI-native design editor. Open-source Figma alternative.
import type { CloudAPIClient } from '@open-pencil/cloud/client'
import {
cloudShareURL,
type CloudDiscovery,
type DocumentPermission,
type DocumentShare
} from '@open-pencil/cloud/contract'
import type { StorageDocumentBinding } from '@/app/integrations/storage/types'
import { findCloudServer, type CloudServer } from '../servers/store'
import { cloudAPIClient, cloudConnection } from '../sessions/connection'
import { clearShareSecret, readShareSecret, saveShareSecret } from './secrets'
/** Someone with access: a person granted it, or an invitation not accepted yet. */
export type CloudShareMember = {
id: string
name: string
email: string
permission: DocumentPermission
/** When a pending invitation expires. */
pendingUntil?: string
you?: boolean
}
export type CloudShareLink =
| { access: 'restricted' }
| { access: 'link'; permission: DocumentPermission; copyable: boolean }
export type CloudSharing = {
canManage: boolean
members: CloudShareMember[]
link: CloudShareLink
/** What the workspace's plan allows for links. */
links: CloudLinkPolicy
}
/**
* Whether the workspace allows links at all, and whether people who are not signed in to the
* server may follow view and edit links; people signed in may follow any link.
*/
export type CloudLinkPolicy = { allowed: boolean; guestView: boolean; guestEdit: boolean }
type Target = {
server: CloudServer
discovery: CloudDiscovery
client: CloudAPIClient
documentId: string
workspaceId: string | null
accountId: string | null
}
const GRANT = 'grant:'
const INVITATION = 'invitation:'
/** The server, client, and document for a Cloud binding, while signed in to its server. */
export function cloudShareTarget(binding: StorageDocumentBinding): Target | null {
const server = binding.profileId ? findCloudServer(binding.profileId) : null
if (!server) return null
const connection = cloudConnection(server.id)
if (connection.state !== 'signed-in' || !connection.discovery) return null
return {
server,
discovery: connection.discovery,
client: cloudAPIClient(server, connection.discovery),
documentId: binding.documentId,
workspaceId: binding.containerId ?? null,
accountId: connection.account?.id ?? null
}
}
const activeShare = (shares: DocumentShare[]) => shares.find((share) => !share.revokedAt) ?? null
/** Who can open the document and whether its link is on, as this account may see it. */
export async function readCloudSharing(target: Target): Promise<CloudSharing> {
const { client, documentId } = target
const access = await client.getDocumentAccess(documentId)
const closed: CloudLinkPolicy = { allowed: false, guestView: false, guestEdit: false }
if (!access.canManageSharing) {
return { canManage: false, members: [], link: { access: 'restricted' }, links: closed }
}
const [grants, invitations, shares, entitlements] = await Promise.all([
client.listDocumentGrants(documentId),
client.listDocumentInvitations(documentId),
client.listDocumentShares(documentId),
target.workspaceId
? client.getWorkspaceEntitlements(target.workspaceId).catch(() => null)
: Promise.resolve(null)
])
const features = entitlements?.features
const links: CloudLinkPolicy = features
? { allowed: features.links, guestView: features.guestView, guestEdit: features.guestEdit }
: closed
const people = await Promise.all(
grants.map(async (grant) => {
const profile = await client.getUserProfile(documentId, grant.userId).catch(() => null)
return {
id: `${GRANT}${grant.userId}`,
name: profile?.name ?? grant.userId,
email: profile?.email ?? '',
permission: grant.permission,
you: grant.userId === target.accountId
}
})
)
const pending = invitations
.filter((invitation) => !invitation.acceptedAt)
.map((invitation) => ({
id: `${INVITATION}${invitation.id}`,
name: invitation.email,
email: invitation.email,
permission: invitation.permission,
pendingUntil: invitation.expiresAt
}))
const share = activeShare(shares)
const link: CloudShareLink = share
? {
access: 'link',
permission: share.permission,
copyable: Boolean(await readShareSecret(target.server.id, share.id))
}
: { access: 'restricted' }
return { canManage: true, members: [...people, ...pending], link, links }
}
export async function inviteToCloudDocument(
target: Target,
email: string,
permission: DocumentPermission
): Promise<void> {
await target.client.createDocumentInvitation(target.documentId, { email, permission })
}
/** Changes or removes a person's access, or withdraws an invitation. */
export async function changeCloudMember(
target: Target,
memberId: string,
change: DocumentPermission | 'remove'
): Promise<void> {
const { client, documentId } = target
if (memberId.startsWith(INVITATION)) {
const invitationId = memberId.slice(INVITATION.length)
if (change === 'remove') await client.revokeDocumentInvitation(documentId, invitationId)
return
}
const userId = memberId.slice(GRANT.length)
if (change === 'remove') await client.revokeDocumentGrant(documentId, userId)
else await client.putDocumentGrant(documentId, userId, { permission: change })
}
/**
* Turns the link off, on with a permission, or changes its permission. A new link's secret is
* kept on this device so the link can be copied here.
*/
export async function changeCloudLink(target: Target, link: CloudShareLink): Promise<void> {
const { client, documentId, server } = target
const share = activeShare(await client.listDocumentShares(documentId))
if (link.access === 'restricted') {
if (!share) return
await client.revokeDocumentShare(documentId, share.id)
await clearShareSecret(server.id, share.id)
return
}
if (share) {
await client.updateDocumentShare(documentId, share.id, { permission: link.permission })
return
}
const created = await client.createDocumentShare(documentId, { permission: link.permission })
await saveShareSecret(server.id, created.share.id, created.secret)
}
/** Replaces the link's secret, so old copies stop working and this device can copy it. */
export async function resetCloudLink(target: Target): Promise<void> {
const { client, documentId, server } = target
const share = activeShare(await client.listDocumentShares(documentId))
if (!share) return
const rotated = await client.rotateDocumentShare(documentId, share.id)
await saveShareSecret(server.id, rotated.share.id, rotated.secret)
}
/** The link to copy, when this device has its secret. */
export async function cloudLinkURL(target: Target): Promise<string | null> {
const share = activeShare(await target.client.listDocumentShares(target.documentId))
if (!share) return null
const secret = await readShareSecret(target.server.id, share.id)
return secret ? cloudShareURL(target.server.url, share.id, secret) : null
}