@things-factory/gallery 0.0.0-stage → 10.1.223

package/package.json

@@ -1,6 +1,50 @@
 {
   "name": "@things-factory/gallery",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "10.1.223",
+  "main": "dist-server/index.js",
+  "browser": "dist-client/index.js",
+  "things-factory": true,
+  "license": "MIT",
+  "author": "heartyoh <heartyoh@hatiolab.com>",
+  "description": "The company gallery - photos posted to the company, a person's own space or an event, tagged and liked by everyone of the domain",
+  "publishConfig": {
+    "access": "public",
+    "@things-factory:registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hatiolab/things-factory.git",
+    "directory": "packages/gallery"
+  },
+  "scripts": {
+    "build": "npm run build:server && npm run build:client",
+    "copy:files": "copyfiles -e \"./client/**/*.{ts,js,json}\" -u 1 \"./client/**/*\" dist-client",
+    "build:client": "npm run clean:client && npm run copy:files && npx tsc --p ./client/tsconfig.json",
+    "build:server": "npm run clean:server && npx tsc --p ./server/tsconfig.json",
+    "clean:server": "rm -rf dist-server",
+    "clean:client": "rm -rf dist-client",
+    "clean": "npm run clean:server && npm run clean:client"
+  },
+  "dependencies": {
+    "@material/web": "^2.0.0",
+    "@operato/graphql": "^10.29.39",
+    "@operato/i18n": "^10.0.0",
+    "@operato/input": "^10.29.52",
+    "@operato/layout": "^10.29.49",
+    "@operato/popup": "^10.29.39",
+    "@operato/shell": "^10.29.39",
+    "@operato/styles": "^10.29.1",
+    "@operato/utils": "^10.0.0",
+    "@things-factory/apptool-base": "^10.1.221",
+    "@things-factory/attachment-base": "^10.1.223",
+    "@things-factory/auth-base": "^10.1.223",
+    "@things-factory/calendar": "^10.1.223",
+    "@things-factory/i18n-base": "^10.1.223",
+    "@things-factory/notification": "^10.1.223",
+    "@things-factory/shell": "^10.1.208",
+    "graphql-tag": "^2.12.6",
+    "graphql-upload": "^15.0.2",
+    "lit": "^3.1.2"
+  },
+  "gitHead": "868f2026b8373371ad04f42b0a097964d0d0ed0f"
+}

package/server/attachment-reader.ts

@@ -0,0 +1,14 @@
+/*
+ * Who may open a gallery photo by its path - whoever sees the post (ADR-0165 decision 7). attachment-base has already
+ * checked the file is of the request's domain.
+ */
+import { registerAttachmentReader } from '@things-factory/attachment-base'
+
+import { GALLERY_REF_TYPE, visiblePost } from './service/gallery/gallery-service'
+
+export function registerGalleryPhotos(): void {
+  registerAttachmentReader(
+    GALLERY_REF_TYPE,
+    async (attachment, context) => !!attachment.refBy && !!(await visiblePost(attachment.refBy, context))
+  )
+}

package/server/index.ts

@@ -0,0 +1,9 @@
+export * from './service'
+
+import { registerRoleTask } from '@things-factory/auth-base'
+
+import { registerGalleryPhotos } from './attachment-reader'
+import { ROLE_TASKS } from './role-tasks'
+
+for (const task of ROLE_TASKS) registerRoleTask(task)
+registerGalleryPhotos()

package/server/role-tasks.ts

@@ -0,0 +1,14 @@
+/*
+ * The work this module names, for the seats applications build (ADR-0139 decision 11).
+ *
+ * Looking, posting and liking are no task: everyone of the domain does them (ADR-0165 decision 2). Hiding a post,
+ * tidying the tags and making an event from the gallery are `gallery.moderation`.
+ *
+ * Data only - `server/index.ts` registers it - so an application's tests read it without starting the framework.
+ */
+
+import type { RoleTask } from '@things-factory/auth-base'
+
+export const ROLE_TASKS: RoleTask[] = [
+  { id: 'gallery.moderation', grants: [{ category: 'gallery', axes: ['mutation'] }] }
+]

package/server/service/gallery/gallery-resolver.ts

@@ -0,0 +1,541 @@
+/*
+ * The doors of the gallery (ADR-0165 decisions 3-7).
+ *
+ * Looking, posting and liking are no privilege: everyone of the domain sees every post (decision 2), so those doors are
+ * open to anyone signed in to the domain and each asks the post itself (gallery-service.ts). Changing or deleting a
+ * post is its owner's. Hiding, tidying tags and making an event are `gallery:mutation` - the task `gallery.moderation`.
+ */
+import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
+import { Arg, Ctx, Directive, FieldResolver, Int, Mutation, Query, Resolver, Root } from 'type-graphql'
+import { In, IsNull, Not } from 'typeorm'
+
+import { Attachment, createAttachment, deleteAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { createEvent, Event } from '@things-factory/calendar'
+import { getRepository } from '@things-factory/shell'
+
+import { GalleryEvent, GalleryLike, GalleryPost, GallerySpace, GalleryVisit } from './gallery'
+import {
+  inputRefusal,
+  isPhoto,
+  MAX_TAG,
+  orderChoices,
+  photoCountRefusal,
+  renamedTags,
+  hasTag,
+  tagCounts,
+  tagOf,
+  tagsOf
+} from './gallery-rules'
+import {
+  decorate,
+  eventsSeenBetween,
+  GALLERY_REF_TYPE,
+  isModerator,
+  maySeeEvent,
+  openEvent,
+  photosOf,
+  tellFirstPhoto,
+  tellHidden,
+  viewerOf,
+  visiblePost
+} from './gallery-service'
+import {
+  GalleryEventCard,
+  GalleryEventChoice,
+  GalleryEventFacts,
+  GalleryEventInput,
+  GalleryFilter,
+  GalleryLikeState,
+  GalleryPerson,
+  GalleryPhoto,
+  GalleryPostInput,
+  GalleryPostList,
+  GallerySummary,
+  GalleryTagCount
+} from './gallery-types'
+
+const MODERATE = '@privilege(category: "gallery", privilege: "mutation", domainOwnerGranted: true)'
+const DAY = 24 * 60 * 60 * 1000
+/* A person who never opened the gallery hears of the last week's posts. */
+const FIRST_LOOK = 7 * DAY
+
+/** A refusal said in the reader's words, with a code the screen may read. */
+function refuse(context: ResolverContext, code: string, fallback: string): never {
+  const message = context.t ? String(context.t(`gallery.refusal.${code}`, { defaultValue: fallback })) : fallback
+  const error: any = new Error(message)
+  error.extensions = { code: `gallery.${code}` }
+  throw error
+}
+
+const NOT_FOUND = 'there is no such post.'
+
+async function visibleOrRefuse(id: string, context: ResolverContext): Promise<GalleryPost> {
+  const post = await visiblePost(id, context, context.state.tx)
+  if (!post) refuse(context, 'unknown-post', NOT_FOUND)
+  return post
+}
+
+async function ownedOrRefuse(id: string, context: ResolverContext): Promise<GalleryPost> {
+  const post = await visibleOrRefuse(id, context)
+  if (post.creatorId !== context.state.user.id)
+    refuse(context, 'not-yours', 'only the one who posted it changes or deletes it.')
+  return post
+}
+
+function checkInput(input: GalleryPostInput, context: ResolverContext): void {
+  const refusal = inputRefusal(input)
+  if (refusal) refuse(context, refusal, `the post cannot be kept (${refusal}).`)
+}
+
+/** The uploads, each checked to be a photo before anything is stored. */
+async function photoUploads(files: FileUpload[] | undefined, context: ResolverContext): Promise<FileUpload[]> {
+  const out: FileUpload[] = []
+  for (const file of files ?? []) {
+    const upload = await file
+    if (!isPhoto(upload?.mimetype)) refuse(context, 'not-a-photo', 'only photos go in the gallery.')
+    out.push(file)
+  }
+  return out
+}
+
+/** The event a post may hang on - one the person may post to - opened for everyone; refused otherwise. */
+async function eventOrRefuse(eventId: string, context: ResolverContext): Promise<string> {
+  const event = await maySeeEvent(eventId, context, context.state.tx)
+  if (!event) refuse(context, 'unknown-event', 'there is no such event to post to.')
+  await openEvent(event.id, context, context.state.tx)
+  return event.id
+}
+
+const factsOf = (event: Event): GalleryEventFacts => ({
+  id: event.id,
+  name: event.name,
+  startAt: event.startAt,
+  endAt: event.endAt,
+  location: event.location ?? undefined
+})
+
+const photoOf = (one: Attachment): GalleryPhoto => ({
+  id: one.id,
+  name: one.name,
+  thumbnail: one.thumbnail ?? undefined,
+  fullpath: one.fullpath,
+  mimetype: one.mimetype ?? undefined
+})
+
+/** The posts the request's person sees, as a query to narrow further. */
+async function seenPosts(context: ResolverContext) {
+  const { domain, user } = context.state
+  const viewer = await viewerOf(context)
+  const qb = getRepository(GalleryPost).createQueryBuilder('P').where('P.domain = :domain', { domain: domain.id })
+  if (!viewer.moderator) qb.andWhere('(P.hiddenAt IS NULL OR P.creator = :me)', { me: user.id })
+  const active = [...viewer.activePeople]
+  /* The own gallery of someone who left is no longer shown (decision 5). */
+  qb.andWhere(
+    active.length
+      ? '(P.space != :personal OR P.creator = :me OR P.creator IN (:...active))'
+      : '(P.space != :personal OR P.creator = :me)',
+    {
+      personal: GallerySpace.PERSONAL,
+      me: user.id,
+      active
+    }
+  )
+  return qb
+}
+
+@Resolver(GalleryPost)
+export class GalleryResolver {
+  /* ---------------------------------------------------------------- looking */
+
+  @Query(returns => GalleryPostList, {
+    description: 'The posts the person sees, newest first - narrowed by space, event, tag or person.'
+  })
+  async galleryPosts(
+    @Arg('filter', type => GalleryFilter, { nullable: true }) filter: GalleryFilter | undefined,
+    @Arg('skip', type => Int, { nullable: true }) skip: number | undefined,
+    @Arg('take', type => Int, { nullable: true }) take: number | undefined,
+    @Ctx() context: ResolverContext
+  ): Promise<GalleryPostList> {
+    const qb = await seenPosts(context)
+    if (filter?.space) qb.andWhere('P.space = :space', { space: filter.space })
+    if (filter?.eventId) qb.andWhere('P.event = :event', { event: filter.eventId })
+    if (filter?.authorId) qb.andWhere('P.creator = :author', { author: filter.authorId })
+    const tag = tagOf(filter?.tag ?? '')
+    /* Tags are kept as a JSON list: the quotes bound the word, so 「워크숍」 does not find 「워크숍2026」. */
+    if (tag) qb.andWhere('LOWER(P.tags) LIKE :tag', { tag: `%${JSON.stringify(tag.toLowerCase())}%` })
+    qb.orderBy('P.createdAt', 'DESC')
+      .skip(Math.max(0, skip ?? 0))
+      .take(Math.min(60, Math.max(1, take ?? 30)))
+    const [items, total] = await qb.getManyAndCount()
+    return { items: await decorate(items, context), total }
+  }
+
+  @Query(returns => GalleryPost, { nullable: true, description: 'One post, when the person sees it.' })
+  async galleryPost(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<GalleryPost | undefined> {
+    const post = await visiblePost(id, context)
+    return post ? (await decorate([post], context))[0] : undefined
+  }
+
+  @Query(returns => [GalleryPerson], { description: 'Who likes the post, the latest first.' })
+  async galleryLikers(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<GalleryPerson[]> {
+    const post = await visibleOrRefuse(id, context)
+    const likes = await getRepository(GalleryLike).find({
+      where: { post: { id: post.id } } as any,
+      relations: ['user'],
+      order: { createdAt: 'DESC' } as any
+    })
+    return likes.map(one => ({ id: one.userId!, name: one.user?.name }))
+  }
+
+  @Query(returns => [GalleryTagCount], {
+    description: 'The tags of the domain the most used first - those holding `text` when given.'
+  })
+  async galleryTags(
+    @Arg('text', { nullable: true }) text: string | undefined,
+    @Ctx() context: ResolverContext
+  ): Promise<GalleryTagCount[]> {
+    const rows = await getRepository(GalleryPost).find({
+      where: { domain: { id: context.state.domain.id }, hiddenAt: IsNull() } as any,
+      select: ['id', 'tags'] as any
+    })
+    return tagCounts(
+      rows.map(one => one.tags),
+      text ?? ''
+    )
+  }
+
+  @Query(returns => [GalleryEventCard], {
+    description: 'The events whose gallery is open, the latest first, each with its posts counted and a photo shown.'
+  })
+  async galleryEvents(@Ctx() context: ResolverContext): Promise<GalleryEventCard[]> {
+    const { domain } = context.state
+    const open = await getRepository(GalleryEvent).find({ where: { domain: { id: domain.id } } as any })
+    if (!open.length) return []
+    const events = await getRepository(Event).find({
+      where: { id: In(open.map(one => one.eventId)), domain: { id: domain.id } } as any,
+      order: { startAt: 'DESC' } as any
+    })
+    if (!events.length) return []
+    const posts = await (
+      await seenPosts(context)
+    )
+      .andWhere('P.event IN (:...events)', { events: events.map(one => one.id) })
+      .orderBy('P.likeCount', 'DESC')
+      .addOrderBy('P.createdAt', 'DESC')
+      .getMany()
+    const byEvent = new Map<string, GalleryPost[]>()
+    for (const one of posts) byEvent.set(one.eventId!, [...(byEvent.get(one.eventId!) ?? []), one])
+    const covers = await photosOf(
+      [...byEvent.values()].map(list => list[0].id),
+      domain.id
+    )
+    return events.map(event => {
+      const list = byEvent.get(event.id) ?? []
+      const cover = list.length ? covers.get(list[0].id)?.[0] : undefined
+      return { ...factsOf(event), postCount: list.length, cover: cover ? photoOf(cover) : undefined }
+    })
+  }
+
+  @Query(returns => [GalleryEventChoice], {
+    description:
+      'The events the person may post photos to - those near when the photo was taken first. Their own events, the open ones, and every event for whoever reads the calendar.'
+  })
+  async galleryEventChoices(
+    @Arg('takenAt', { nullable: true }) takenAt: Date | undefined,
+    @Ctx() context: ResolverContext
+  ): Promise<GalleryEventChoice[]> {
+    const at = takenAt && !isNaN(new Date(takenAt).getTime()) ? new Date(takenAt) : new Date()
+    const events = await eventsSeenBetween(context, new Date(at.getTime() - 45 * DAY), new Date(at.getTime() + 3 * DAY))
+    return orderChoices(events.map(factsOf), at)
+  }
+
+  @Query(returns => GallerySummary, {
+    description: 'How many posts others made since the person last opened the gallery.'
+  })
+  async gallerySummary(@Ctx() context: ResolverContext): Promise<GallerySummary> {
+    const { domain, user } = context.state
+    const visit = await getRepository(GalleryVisit).findOne({
+      where: { domain: { id: domain.id }, user: { id: user.id } } as any
+    })
+    const since = visit?.seenAt ?? new Date(Date.now() - FIRST_LOOK)
+    const fresh = await (
+      await seenPosts(context)
+    )
+      .andWhere('P.createdAt > :since', { since })
+      .andWhere('P.creator != :me', { me: user.id })
+      .getCount()
+    return { fresh }
+  }
+
+  /* ---------------------------------------------------------------- posting */
+
+  @Directive('@transaction')
+  @Mutation(returns => GalleryPost, {
+    description: 'Posts photos - at least one - with a caption, tags and an event when given.'
+  })
+  async createGalleryPost(
+    @Arg('input', type => GalleryPostInput) input: GalleryPostInput,
+    @Arg('photos', type => [GraphQLUpload]) photos: FileUpload[],
+    @Ctx() context: ResolverContext
+  ): Promise<GalleryPost> {
+    const { domain, user, tx } = context.state as any
+    checkInput(input, context)
+    const countRefusal = photoCountRefusal(photos?.length ?? 0)
+    if (countRefusal) refuse(context, countRefusal, `a post holds 1 to 20 photos (${countRefusal}).`)
+    const uploads = await photoUploads(photos, context)
+    const eventId = input.eventId ? await eventOrRefuse(input.eventId, context) : null
+    const post = await getRepository(GalleryPost, tx).save({
+      domain,
+      space: eventId ? GallerySpace.COMPANY : (input.space ?? GallerySpace.COMPANY),
+      caption: input.caption?.trim() || null,
+      takenAt: input.takenAt ?? new Date(),
+      tags: tagsOf(input.tags),
+      event: eventId ? { id: eventId } : null,
+      likeCount: 0,
+      creator: user,
+      updater: user
+    } as any)
+    for (const file of uploads)
+      await createAttachment(null, { attachment: { file, refType: GALLERY_REF_TYPE, refBy: post.id } } as any, context)
+    if (eventId) await tellFirstPhoto(context, post, eventId)
+    return (await decorate([await getRepository(GalleryPost, tx).findOneBy({ id: post.id })], context))[0]
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => GalleryPost, {
+    description: "Changes one's own post - its caption, tags, space, event and photos; at least one photo stays."
+  })
+  async updateGalleryPost(
+    @Arg('id') id: string,
+    @Arg('input', type => GalleryPostInput) input: GalleryPostInput,
+    @Arg('attach', type => [GraphQLUpload], { nullable: true }) attach: FileUpload[] | undefined,
+    @Arg('remove', type => [String], { nullable: true }) remove: string[] | undefined,
+    @Ctx() context: ResolverContext
+  ): Promise<GalleryPost> {
+    const { domain, user, tx } = context.state as any
+    const post = await ownedOrRefuse(id, context)
+    checkInput(input, context)
+    const current = (await photosOf([post.id], domain.id, tx)).get(post.id) ?? []
+    const removing = current.filter(one => (remove ?? []).includes(one.id))
+    const countRefusal = photoCountRefusal(current.length - removing.length + (attach?.length ?? 0))
+    if (countRefusal) refuse(context, countRefusal, `a post holds 1 to 20 photos (${countRefusal}).`)
+    const uploads = await photoUploads(attach, context)
+    const eventId = input.eventId
+      ? input.eventId === post.eventId
+        ? post.eventId
+        : await eventOrRefuse(input.eventId, context)
+      : null
+    await getRepository(GalleryPost, tx).update(post.id, {
+      space: eventId ? GallerySpace.COMPANY : (input.space ?? post.space),
+      caption: input.caption?.trim() || null,
+      takenAt: input.takenAt ?? post.takenAt,
+      tags: tagsOf(input.tags),
+      event: eventId ? { id: eventId } : null,
+      updater: user
+    } as any)
+    for (const one of removing) await deleteAttachment(null, { id: one.id }, context)
+    for (const file of uploads)
+      await createAttachment(null, { attachment: { file, refType: GALLERY_REF_TYPE, refBy: post.id } } as any, context)
+    if (eventId && eventId !== post.eventId) await tellFirstPhoto(context, post, eventId)
+    return (await decorate([await getRepository(GalleryPost, tx).findOneBy({ id: post.id })], context))[0]
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: "Deletes one's own post with its photos." })
+  async deleteGalleryPost(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx, user } = context.state as any
+    const post = await ownedOrRefuse(id, context)
+    await deleteAttachmentsByRef(null, { refBys: [post.id], refType: GALLERY_REF_TYPE }, context)
+    await getRepository(GalleryLike, tx).softDelete({ post: { id: post.id } } as any)
+    await getRepository(GalleryPost, tx).update(post.id, { updater: user } as any)
+    await getRepository(GalleryPost, tx).softDelete(post.id)
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => GalleryLikeState, {
+    description: 'Likes a post, or takes the like back - liking it twice changes nothing.'
+  })
+  async likeGalleryPost(
+    @Arg('id') id: string,
+    @Arg('like') like: boolean,
+    @Ctx() context: ResolverContext
+  ): Promise<GalleryLikeState> {
+    const { domain, user, tx } = context.state as any
+    const post = await visibleOrRefuse(id, context)
+    const repository = getRepository(GalleryLike, tx)
+    const mine = await repository.findOne({ where: { post: { id: post.id }, user: { id: user.id } } as any })
+    if (like && !mine)
+      await repository.save({
+        domain,
+        post: { id: post.id },
+        user: { id: user.id },
+        creator: user,
+        updater: user
+      } as any)
+    if (!like && mine) await repository.softDelete(mine.id)
+    const likeCount = await repository.count({ where: { post: { id: post.id } } as any })
+    await getRepository(GalleryPost, tx).update(post.id, { likeCount } as any)
+    return { id: post.id, likeCount, liked: like }
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, {
+    description: 'Records that the person opened the gallery - the menu counts the posts after it.'
+  })
+  async visitGallery(@Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, user, tx } = context.state as any
+    const repository = getRepository(GalleryVisit, tx)
+    const visit = await repository.findOne({ where: { domain: { id: domain.id }, user: { id: user.id } } as any })
+    if (visit) await repository.update(visit.id, { seenAt: new Date(), updater: user } as any)
+    else
+      await repository.save({ domain, user: { id: user.id }, seenAt: new Date(), creator: user, updater: user } as any)
+    return true
+  }
+
+  /* ---------------------------------------------------------------- moderating */
+
+  @Directive(MODERATE)
+  @Directive('@transaction')
+  @Mutation(returns => GalleryPost, {
+    description:
+      'Hides a post with the reason - its owner is told, and still sees it marked hidden. Undone by unhideGalleryPost.'
+  })
+  async hideGalleryPost(
+    @Arg('id') id: string,
+    @Arg('reason') reason: string,
+    @Ctx() context: ResolverContext
+  ): Promise<GalleryPost> {
+    const { user, tx } = context.state as any
+    const post = await visibleOrRefuse(id, context)
+    const why = (reason ?? '').trim()
+    if (!why) refuse(context, 'reason-required', 'give the reason it is hidden.')
+    if (why.length > 200) refuse(context, 'reason-too-long', 'the reason is at most 200 characters.')
+    await getRepository(GalleryPost, tx).update(post.id, {
+      hiddenAt: new Date(),
+      hiddenReason: why,
+      hiddenBy: user,
+      updater: user
+    } as any)
+    await tellHidden(context, post, why)
+    return (await decorate([await getRepository(GalleryPost, tx).findOneBy({ id: post.id })], context))[0]
+  }
+
+  @Directive(MODERATE)
+  @Directive('@transaction')
+  @Mutation(returns => GalleryPost, { description: 'Shows a hidden post again.' })
+  async unhideGalleryPost(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<GalleryPost> {
+    const { user, tx } = context.state as any
+    const post = await visibleOrRefuse(id, context)
+    await getRepository(GalleryPost, tx).update(post.id, {
+      hiddenAt: null,
+      hiddenReason: null,
+      hiddenBy: null,
+      updater: user
+    } as any)
+    return (await decorate([await getRepository(GalleryPost, tx).findOneBy({ id: post.id })], context))[0]
+  }
+
+  @Directive(MODERATE)
+  @Directive('@transaction')
+  @Mutation(returns => Int, {
+    description:
+      'Renames a tag on every post of the domain - into a tag already there, the two become one. Answers how many posts changed.'
+  })
+  async renameGalleryTag(
+    @Arg('from') from: string,
+    @Arg('to') to: string,
+    @Ctx() context: ResolverContext
+  ): Promise<number> {
+    const { domain, user, tx } = context.state as any
+    const target = tagOf(to)
+    if (!tagOf(from) || !target) refuse(context, 'tag-required', 'give the tag and its new name.')
+    if (target.length > MAX_TAG) refuse(context, 'tag-too-long', 'a tag is at most 30 characters.')
+    const repository = getRepository(GalleryPost, tx)
+    const rows = await repository.find({
+      where: { domain: { id: domain.id }, tags: Not(IsNull()) } as any,
+      select: ['id', 'tags'] as any
+    })
+    let changed = 0
+    for (const one of rows) {
+      if (!hasTag(one.tags, from)) continue
+      await repository.update(one.id, { tags: renamedTags(one.tags, from, target), updater: user } as any)
+      changed++
+    }
+    return changed
+  }
+
+  @Directive(MODERATE)
+  @Directive('@transaction')
+  @Mutation(returns => GalleryEventCard, {
+    description:
+      'Makes a company event on the calendar and opens its gallery - for the events nobody put on the calendar yet.'
+  })
+  async createGalleryEvent(
+    @Arg('input', type => GalleryEventInput) input: GalleryEventInput,
+    @Ctx() context: ResolverContext
+  ): Promise<GalleryEventCard> {
+    const { domain, user, tx } = context.state as any
+    const event = await createEvent(tx, domain, user, {
+      name: input.name,
+      startAt: input.startAt,
+      endAt: input.endAt,
+      location: input.location
+    } as any)
+    await openEvent(event.id, context, tx)
+    return { ...factsOf(event), postCount: 0 }
+  }
+
+  /* ---------------------------------------------------------------- a post's fields */
+
+  @FieldResolver(type => [GalleryPhoto], { description: 'The photos, in the order they were added.' })
+  async photos(@Root() post: GalleryPost, @Ctx() context: ResolverContext): Promise<GalleryPhoto[]> {
+    const rows = (post as any).__photos ?? (await photosOf([post.id], context.state.domain.id)).get(post.id) ?? []
+    return rows.map(photoOf)
+  }
+
+  @FieldResolver(type => User, { nullable: true, description: 'Who posted it - the owner.' })
+  async creator(@Root() post: GalleryPost): Promise<User | undefined> {
+    if ((post as any).__creator !== undefined) return (post as any).__creator ?? undefined
+    return post.creatorId ? await getRepository(User).findOneBy({ id: post.creatorId }) : undefined
+  }
+
+  @FieldResolver(type => GalleryEventFacts, {
+    nullable: true,
+    description: 'The event the photos are of - its name, time and place.'
+  })
+  async event(@Root() post: GalleryPost): Promise<GalleryEventFacts | undefined> {
+    const event =
+      (post as any).__event ?? (post.eventId ? await getRepository(Event).findOneBy({ id: post.eventId }) : null)
+    return event ? factsOf(event) : undefined
+  }
+
+  @FieldResolver(type => Boolean, { description: 'Whether the person likes it.' })
+  async liked(@Root() post: GalleryPost, @Ctx() context: ResolverContext): Promise<boolean> {
+    if ((post as any).__liked !== undefined) return (post as any).__liked
+    return !!(await getRepository(GalleryLike).findOne({
+      where: { post: { id: post.id }, user: { id: context.state.user.id } } as any
+    }))
+  }
+
+  @FieldResolver(type => Boolean, { description: "Whether it is the person's own - they change and delete it." })
+  editable(@Root() post: GalleryPost, @Ctx() context: ResolverContext): boolean {
+    return post.creatorId === context.state.user?.id
+  }
+
+  @FieldResolver(type => Boolean, { description: 'Whether the person may hide it or show it again.' })
+  async moderatable(@Ctx() context: ResolverContext): Promise<boolean> {
+    return await isModerator(context)
+  }
+
+  @FieldResolver(type => String, {
+    nullable: true,
+    description: 'Why it was hidden - for its owner and the moderators.'
+  })
+  async hiddenReason(@Root() post: GalleryPost, @Ctx() context: ResolverContext): Promise<string | undefined> {
+    if (!post.hiddenAt) return undefined
+    return post.creatorId === context.state.user?.id || (await isModerator(context)) ? post.hiddenReason : undefined
+  }
+}