import type { FileData, PayloadRequest, TypeWithID, Where } from 'payload' import { buildStoragePathData, isStoragePathWithinCollectionPrefix, } from '@payloadcms/plugin-cloud-storage/utilities' import { combineQueries, executeAccess, Forbidden } from 'payload' type OwnerDocument = { prefix?: string } & FileData & TypeWithID export type VercelBlobCollectionSource = { collectionPrefix: string collectionSlug: string useCompositePrefixes: boolean } type Owner = { collectionSlug: string doc: OwnerDocument } function getDocumentFileKeys({ collectionPrefix, doc, useCompositePrefixes, }: { collectionPrefix: string doc: OwnerDocument useCompositePrefixes: boolean }): string[] { return [doc.filename, ...Object.values(doc.variants || {}).map((size) => size?.filename)] .filter((filename): filename is string => typeof filename === 'string') .map( (filename) => buildStoragePathData({ collectionPrefix, docPrefix: doc.prefix, filename, useCompositePrefixes, }).storageFilePath, ) } async function findMatchingDocs({ collectionPrefix, collectionSlug, req, requestedFilename, requestedStorageFilePath, useCompositePrefixes, }: { collectionPrefix: string collectionSlug: string req: PayloadRequest requestedFilename: string requestedStorageFilePath: string useCompositePrefixes: boolean }): Promise { const collection = req.payload.collections[collectionSlug] if (!collection) { return [] } const variants = collection.config.upload && typeof collection.config.upload === 'object' ? collection.config.upload.variants || [] : [] const filenameQueries: Where[] = [ { filename: { equals: requestedFilename } }, ...variants.map(({ name }) => ({ [`variants.${name}.filename`]: { equals: requestedFilename }, })), ] const result = await req.payload.find({ collection: collectionSlug, depth: 0, draft: true, overrideAccess: true, pagination: false, req, where: { or: filenameQueries }, }) return (result.docs as OwnerDocument[]).filter((doc) => getDocumentFileKeys({ collectionPrefix, doc, useCompositePrefixes }).includes( requestedStorageFilePath, ), ) } async function canUpdateDoc({ collectionSlug, doc, req, }: { collectionSlug: string doc: OwnerDocument req: PayloadRequest }): Promise { const collection = req.payload.collections[collectionSlug] if (!collection) { return false } const accessResult = await executeAccess( { id: doc.id, slug: collectionSlug, disableErrors: true, req }, collection.config.access.update, ) if (typeof accessResult === 'boolean') { return accessResult } const result = await req.payload.find({ collection: collectionSlug, depth: 0, draft: true, limit: 1, overrideAccess: true, pagination: false, req, where: combineQueries({ id: { equals: doc.id } }, accessResult), }) return result.docs.length === 1 } export async function authorizeClientOverwrite({ collectionPrefix: collectionPrefixArg, collectionSources, overrideAccess = false, req, requestedCollectionSlug, requestedFilename, requestedStorageFilePath, }: { collectionPrefix: string collectionSources: VercelBlobCollectionSource[] overrideAccess?: boolean req: PayloadRequest requestedCollectionSlug: string requestedFilename: string requestedStorageFilePath: string }): Promise { if ( !isStoragePathWithinCollectionPrefix({ collectionPrefix: collectionPrefixArg, docPrefix: requestedStorageFilePath, }) ) { throw new Forbidden(req.t) } const matchedDocs = ( await Promise.all( collectionSources.map( async ({ collectionPrefix, collectionSlug, useCompositePrefixes }): Promise => { const docs = await findMatchingDocs({ collectionPrefix, collectionSlug, req, requestedFilename, requestedStorageFilePath, useCompositePrefixes, }) return docs.map((doc) => ({ collectionSlug, doc })) }, ), ) ).flat() if (matchedDocs.length === 0) { return false } const matchedDoc = matchedDocs[0]! if (matchedDocs.length !== 1 || matchedDoc.collectionSlug !== requestedCollectionSlug) { throw new Forbidden(req.t) } if ( !overrideAccess && !(await canUpdateDoc({ collectionSlug: matchedDoc.collectionSlug, doc: matchedDoc.doc, req })) ) { throw new Forbidden(req.t) } return true }