mirror of
https://github.com/shumaiOne/shumai.git
synced 2026-11-22 18:08:24 +00:00
* feat(sharelink): add sharelink watermark support
* fix(sharelink): harden watermark feature against races, crashes, and tenant leaks
Addresses review findings on the sharelink watermark feature:
- fix(watermark): read back sharelink via transaction client so the
updateShareLinkWatermark response reflects the just-committed state
(global-client reads on a pooled connection miss uncommitted changes)
- fix(watermark): use prisma upsert on the config hash instead of
find-then-create to avoid P2002 races on concurrent enables
- fix(watermark): resolve nested symlinks when walking the share tree and
batch the walk level-by-level instead of one query per node
- fix(watermark): keep watermark tasks in flight from being purged by
orphan-config GC (avoids FK violations in completing activities)
- fix(transcode): re-transcode stale 'processing' watermark rows instead
of silently skipping (crash recovery); downscale embedded block images;
use pino structured logging; drop unused any casts
- fix(api): scope watermark-template list/create to the caller's teams,
reject teamless template creation, and make teamless templates
read-only; validate watermark config required when enabling (400);
map sharelink-not-found to 404
- fix(api): resolve symlink target ids once in public share children
endpoint instead of twice per item
- refactor(db): dedicated WatermarkFileStatus enum (migration included)
- test: activity unit tests (init crash recovery, image + video transcode
paths), concurrent upsert, nested-symlink resolution, API scoping and
validation, e2e video watermark path
* refactor(transcode): move sharp usage out of watermark activity into transcodeService
The transcode package does not declare sharp as a dependency (only
@shumai/core does), so importing it directly in the watermark activity
broke CI typecheck for the transcode package.
- add transcodeService.renderSvgToPng, downscaleImageToPng and
compositeOverlayToWebpFile encapsulating the sharp logic
- watermark activity now calls these methods instead of importing sharp
- activity tests mock the new methods (no sharp/real fixture needed)
- add unit tests for the new transcodeService helpers
* feat(watermark): restrict watermark transcode to existing image and video transcodes
* refactor(transcode): reuse transcodeVideo in watermark activity
* refactor(watermark): use Bun.hash instead of node crypto for watermark config hash
* refactor(watermark): move computeWatermarkConfigHash from dtos to core watermark-hash module
* refactor(api): delegate watermark DB queries from public-share route to watermarkService
* refactor(share): replace dynamic watermarkService import with static import
* feat(watermark): add waitForWatermarkFileActivity for in-flight watermark transcoding tasks
* refactor(asset): replace dynamic watermarkService import with static import
* test(watermark): harden purgeOrphanWatermarkConfigs coverage
Replace the single happy-path GC test with a dedicated suite covering:
- orphan config with proxies: purged, watermarkFiles removed, all four
proxy keys deleted from S3 while the original key is preserved
- config still referenced by a share link is not purged
- config with pending/processing transcode_watermark tasks is not purged
(in-flight guard), but completed tasks do not block purging
- pending tasks of other types (transcode_video) do not protect a config
- an S3 delete failure is non-fatal: remaining keys still deleted and the
config is still purged
- mixed run: only the orphan config is purged while a referenced one
survives (exact count assertion)
* feat(webui): add sharelink watermark editor and sidebar controls
* style(webui): enlarge watermark editor dialog and allocate 2/3 width to preview column
* fix(webui): override sm:max-w-lg in DialogContent to allow full 1400px width
* fix(webui): stop block click propagation and remove preview mode toggles
* fix(webui): store watermark block size as fraction of canvas width
The editor stored block.size in pixels (slider 10-120px, preview
fontSize: `${block.size}px`) while the SVG generator
(generateWatermarkSvg) interprets size as a fraction (0..1) of canvas
width. A 36px block therefore rendered as a ~36x-canvas glyph covering
the entire image.
- Keep backend fraction semantics (canvasWidth * size) so watermarks
scale proportionally with output resolution across proxies
- Editor: defaults (text 5%, image 15%), slider ranges (1-12% / 2-50%)
and number input now work in percent, storing a fraction
- Preview: scales blocks by the measured canvas width so WYSIWYG
- DTO schema: size constrained to (0..1) to enforce the contract
- Update DTO/editor tests to fraction sizes
* feat(webui): add single-row aspect ratio selector and 5 predefined background colors to watermark editor preview
* feat(webui): update aspect ratio to multi-toggle group and enable dot-grid pattern for all background colors
* fix(webui): update background swatches to distinct colors and share PRESET_BACKGROUND_OPTIONS array
* fix(webui): hide redundant absolute close button on watermark editor dialog header
* fix(transcode): skip raw video transcode when generating watermark proxies
The raw marker entry (isRaw: true) in videoTranscodes points at the
original source file and is only used to offer the 'Original' playback
option. It is not a transcoded proxy, so watermarking it produced a
redundant full-resolution transcode (the most expensive pass) plus an
unneeded S3 upload.
Skip entries with isRaw: true in transcodeWatermarkMediaActivity, and
cover the behavior with a unit regression test plus an e2e assertion
that exactly one watermark proxy is produced for a video asset.
* feat(webui): replace watermark image asset ID with 1MB file uploader
* fix(webui): correct watermark editor preview block sizing
The preview canvas width was measured in a useEffect([open]) that ran
before the Radix Dialog had mounted its content, so canvasRef.current was
still null, canvasWidthPx stayed 0, and every block silently fell back to
the hardcoded 640px width (block.size * (canvasWidthPx || 640)). A 100%
size therefore rendered at ~640px on an ~876px canvas (~72%), making the
preview smaller than the real watermarked output for both image and text
blocks.
- Measure the canvas via a ref callback (fires exactly when the node
mounts, regardless of dialog mount timing) and keep a ResizeObserver
attached for aspect-ratio/window changes.
- Use clientWidth (padding-box width) instead of getBoundingClientRect(),
which includes the dialog's zoom-in-95 animation transform.
- Drop max-w-full/max-h-full on the preview <img> so logos scale up to
the block size like the backend SVG rendering does, instead of being
capped at their natural pixel size.
* fix(webui): keep watermark editor preview aspect ratio and restore config scroll
- Compute the preview canvas size with a JS contain-fit (ResizeObserver on the
frame) instead of relying on CSS aspect-ratio + w-full/max-h-full, which
broke the selected ratio on wide-and-short (or tall-and-narrow) windows.
- Add min-h-0 to the config ScrollArea so it shrinks to the column's remaining
height instead of growing to its content height, restoring the scroll range.
* fix(webui): remove toast notification on template load
* fix(share): serve per-file watermark proxies in public share APIs
Stop gating watermark replacement on the share-link-wide watermarkStatus.
Public share endpoints now resolve each asset's own completed watermark
proxy and:
- replace videoTranscodes/imageTranscodes with the watermarked entries
when the watermark file is completed;
- empty those arrays when no completed proxy exists yet (still
transcoding or failed) so original, unwatermarked media is never
exposed while a newly added file is being processed;
- leave non-video/image media (pdf, audio, ...) untouched, since they
never receive watermark transcodes.
This removes the previous behavior where adding a file to a ready
watermark share flipped the whole share link to processing and served
original media for every file until the new transcode finished.
Adds API tests for detail/children endpoints (ready, in-flight, pdf, and
watermark-disabled cases) and a workflow E2E test for adding an asset to
an already-ready watermark sharelink.
241 lines
6.6 KiB
TypeScript
241 lines
6.6 KiB
TypeScript
import { Hono } from 'hono'
|
|
import { zValidator } from '@hono/zod-validator'
|
|
import { authzService, Permission, ResourceType } from '@shumai/core/src/authz/authz'
|
|
import { shareService } from '@shumai/core/src/share/share'
|
|
import { projectService } from '@shumai/core/src/project/project'
|
|
import {
|
|
createShareLinkRequestSchema,
|
|
updateShareLinkRequestSchema,
|
|
listShareLinksRequestSchema,
|
|
addAssetToShareRequestSchema,
|
|
updateShareLinkWatermarkRequestSchema,
|
|
AuditAction,
|
|
} from '@shumai/dtos'
|
|
import type { Prisma } from '@shumai/db'
|
|
import { auditLogService } from '@shumai/core/src/auditLog/auditLog'
|
|
import { watermarkService } from '@shumai/core/src/watermark/watermark'
|
|
import {
|
|
ShareLinkNotFoundError,
|
|
ShareLinkWatermarkProcessingError,
|
|
} from '@shumai/core/src/share/errors'
|
|
|
|
type User = Prisma.UserGetPayload<Record<string, never>>
|
|
|
|
const route = new Hono<{ Variables: { user: User } }>()
|
|
.post(
|
|
'/projects/:projectId/shares',
|
|
zValidator('json', createShareLinkRequestSchema),
|
|
async (c) => {
|
|
const projectId = c.req.param('projectId')
|
|
const user = c.get('user')
|
|
const req = c.req.valid('json')
|
|
|
|
await authzService.hasPermission({
|
|
user,
|
|
permission: Permission.Edit,
|
|
type: ResourceType.Project,
|
|
id: projectId,
|
|
})
|
|
|
|
const shareLink = await shareService.createShareLink(projectId, req, user.id)
|
|
|
|
const teamId = await projectService.getProjectTeam(projectId).catch(() => null)
|
|
if (teamId) {
|
|
await auditLogService.logAction({
|
|
action: AuditAction.share_create,
|
|
teamId,
|
|
userId: user.id,
|
|
projectId,
|
|
itemId: shareLink.id,
|
|
})
|
|
}
|
|
|
|
return c.json(shareLink)
|
|
},
|
|
)
|
|
.get(
|
|
'/projects/:projectId/shares',
|
|
zValidator('query', listShareLinksRequestSchema),
|
|
async (c) => {
|
|
const projectId = c.req.param('projectId')
|
|
const user = c.get('user')
|
|
const req = c.req.valid('query')
|
|
|
|
await authzService.hasPermission({
|
|
user,
|
|
permission: Permission.Read,
|
|
type: ResourceType.Project,
|
|
id: projectId,
|
|
})
|
|
|
|
const res = await shareService.listProjectShareLinks({
|
|
...req,
|
|
projectId,
|
|
})
|
|
|
|
return c.json(res)
|
|
},
|
|
)
|
|
.get('/shares/:shareId', async (c) => {
|
|
const shareId = c.req.param('shareId')
|
|
const user = c.get('user')
|
|
|
|
await authzService.hasPermission({
|
|
user,
|
|
permission: Permission.Read,
|
|
type: ResourceType.Share,
|
|
id: shareId,
|
|
})
|
|
|
|
const shareLink = await shareService.getShareLink(shareId)
|
|
return c.json(shareLink)
|
|
})
|
|
.put('/shares/:shareId', zValidator('json', updateShareLinkRequestSchema), async (c) => {
|
|
const shareId = c.req.param('shareId')
|
|
const user = c.get('user')
|
|
const req = c.req.valid('json')
|
|
|
|
await authzService.hasPermission({
|
|
user,
|
|
permission: Permission.Edit,
|
|
type: ResourceType.Share,
|
|
id: shareId,
|
|
})
|
|
|
|
const existingShare = await shareService.getShareLink(shareId)
|
|
const updated = await shareService.updateShareLink(shareId, req)
|
|
|
|
if (existingShare) {
|
|
const teamId = await projectService.getProjectTeam(existingShare.projectId).catch(() => null)
|
|
if (teamId) {
|
|
await auditLogService.logAction({
|
|
action: AuditAction.share_update,
|
|
teamId,
|
|
userId: user.id,
|
|
projectId: existingShare.projectId,
|
|
itemId: shareId,
|
|
})
|
|
}
|
|
}
|
|
|
|
return c.json(updated)
|
|
})
|
|
.delete('/shares/:shareId', async (c) => {
|
|
const shareId = c.req.param('shareId')
|
|
const user = c.get('user')
|
|
|
|
await authzService.hasPermission({
|
|
user,
|
|
permission: Permission.Edit,
|
|
type: ResourceType.Share,
|
|
id: shareId,
|
|
})
|
|
|
|
const existingShare = await shareService.getShareLink(shareId)
|
|
await shareService.deleteShareLink(shareId)
|
|
|
|
if (existingShare) {
|
|
const teamId = await projectService.getProjectTeam(existingShare.projectId).catch(() => null)
|
|
if (teamId) {
|
|
await auditLogService.logAction({
|
|
action: AuditAction.share_delete,
|
|
teamId,
|
|
userId: user.id,
|
|
projectId: existingShare.projectId,
|
|
itemId: shareId,
|
|
})
|
|
}
|
|
}
|
|
|
|
return c.body(null, 204)
|
|
})
|
|
.post('/shares/:shareId/assets', zValidator('json', addAssetToShareRequestSchema), async (c) => {
|
|
const shareId = c.req.param('shareId')
|
|
const user = c.get('user')
|
|
const req = c.req.valid('json')
|
|
|
|
await authzService.hasPermission({
|
|
user,
|
|
permission: Permission.Edit,
|
|
type: ResourceType.Share,
|
|
id: shareId,
|
|
})
|
|
|
|
// Also check if user has read permission on the source assets
|
|
for (const assetId of req.assetIds) {
|
|
await authzService.hasPermission({
|
|
user,
|
|
permission: Permission.Read,
|
|
type: ResourceType.Asset,
|
|
id: assetId,
|
|
})
|
|
}
|
|
|
|
const addedCount = await shareService.addAssetToShare(shareId, req)
|
|
return c.json({ addedCount })
|
|
})
|
|
.delete('/shares/:shareId/assets/:assetId', async (c) => {
|
|
const shareId = c.req.param('shareId')
|
|
const assetId = c.req.param('assetId') // symlink asset id
|
|
const user = c.get('user')
|
|
|
|
await authzService.hasPermission({
|
|
user,
|
|
permission: Permission.Edit,
|
|
type: ResourceType.Share,
|
|
id: shareId,
|
|
})
|
|
|
|
await shareService.removeAssetFromShare(shareId, assetId)
|
|
return c.body(null, 204)
|
|
})
|
|
.put(
|
|
'/shares/:shareId/watermark',
|
|
zValidator('json', updateShareLinkWatermarkRequestSchema),
|
|
async (c) => {
|
|
const shareId = c.req.param('shareId')
|
|
const user = c.get('user')
|
|
const req = c.req.valid('json')
|
|
|
|
await authzService.hasPermission({
|
|
user,
|
|
permission: Permission.Edit,
|
|
type: ResourceType.Share,
|
|
id: shareId,
|
|
})
|
|
|
|
try {
|
|
const updated = await watermarkService.updateShareLinkWatermark(
|
|
shareId,
|
|
req.enabled,
|
|
req.config,
|
|
)
|
|
return c.json(updated)
|
|
} catch (err) {
|
|
if (err instanceof ShareLinkWatermarkProcessingError) {
|
|
return c.json({ error: err.message }, 409)
|
|
}
|
|
if (err instanceof ShareLinkNotFoundError) {
|
|
return c.json({ error: err.message }, 404)
|
|
}
|
|
throw err
|
|
}
|
|
},
|
|
)
|
|
.get('/shares/:shareId/watermark', async (c) => {
|
|
const shareId = c.req.param('shareId')
|
|
const user = c.get('user')
|
|
|
|
await authzService.hasPermission({
|
|
user,
|
|
permission: Permission.Read,
|
|
type: ResourceType.Share,
|
|
id: shareId,
|
|
})
|
|
|
|
const res = await watermarkService.getShareLinkWatermark(shareId)
|
|
return c.json(res)
|
|
})
|
|
|
|
export default route
|