@things-factory/gallery 0.0.0-stage → 10.1.223

package/server/service/gallery/gallery.ts

@@ -0,0 +1,266 @@
+/*
+ * The tables of the gallery (ADR-0165 decisions 2, 4-6): a post of photos, a like, an event its gallery is open for,
+ * and when a person last looked. The photos themselves are attachments hung on the post (`refType: 'Gallery Post'`);
+ * an event is calendar's.
+ */
+import {
+  Column,
+  CreateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import { Field, ID, Int, ObjectType, registerEnumType } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { Event } from '@things-factory/calendar'
+import { Domain } from '@things-factory/shell'
+
+/** Where a post lives. Both are seen by everyone of the domain - the space says only whose it is and where it shows. */
+export enum GallerySpace {
+  /** The company's - events, workshops and work. */
+  COMPANY = 'COMPANY',
+  /** The person's own - their days, hobbies and pets. */
+  PERSONAL = 'PERSONAL'
+}
+
+registerEnumType(GallerySpace, {
+  name: 'GallerySpace',
+  description: "Where a gallery post lives: the company's gallery or the person's own."
+})
+
+@Entity()
+@Index('ix_gallery_post_0', (one: GalleryPost) => [one.domain, one.createdAt])
+@Index('ix_gallery_post_1', (one: GalleryPost) => [one.domain, one.event])
+@Index('ix_gallery_post_2', (one: GalleryPost) => [one.domain, one.creator])
+@ObjectType({
+  description: 'A post of the gallery - one or more photos, a short caption and tags, seen by everyone of the domain.'
+})
+export class GalleryPost {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID, { description: 'Post id.' })
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true, description: 'The domain the post is in.' })
+  domain?: Domain
+
+  @RelationId((one: GalleryPost) => one.domain)
+  domainId?: string
+
+  @Column({ default: GallerySpace.COMPANY })
+  @Field(type => GallerySpace, { description: "The company's gallery or the person's own." })
+  space: GallerySpace
+
+  @Column({ type: 'text', nullable: true })
+  @Field({ nullable: true, description: 'A short caption, plain text.' })
+  caption?: string
+
+  @Column()
+  @Field({ description: 'When the photos were taken - from the first photo, or when it was posted.' })
+  takenAt: Date
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => [String], { nullable: true, description: 'The tags, without the # mark.' })
+  tags?: string[]
+
+  /* Read as its name, time and place (GalleryEventFacts) - the post's field never hands out the calendar's event. */
+  @ManyToOne(type => Event, { nullable: true })
+  event?: Event
+
+  @RelationId((one: GalleryPost) => one.event)
+  eventId?: string
+
+  @Column('int', { default: 0 })
+  @Field(type => Int, { description: 'How many people like it.' })
+  likeCount: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'When a moderator hid it; hidden, only its owner and the moderators see it.' })
+  hiddenAt?: Date
+
+  @Column({ nullable: true })
+  hiddenReason?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  hiddenBy?: User
+
+  @RelationId((one: GalleryPost) => one.hiddenBy)
+  hiddenById?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true, description: 'When it was posted.' })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true, description: 'When it last changed.' })
+  updatedAt?: Date
+
+  @DeleteDateColumn()
+  @Field({ nullable: true, description: 'When its owner deleted it.' })
+  deletedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'Who posted it - the owner.' })
+  creator?: User
+
+  @RelationId((one: GalleryPost) => one.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'Who changed it last.' })
+  updater?: User
+
+  @RelationId((one: GalleryPost) => one.updater)
+  updaterId?: string
+}
+
+@Entity()
+@Index('ix_gallery_like_0', (one: GalleryLike) => [one.post, one.user], { unique: true, where: '"deleted_at" IS NULL' })
+@ObjectType({ description: 'One person liking one gallery post.' })
+export class GalleryLike {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID, { description: 'Like id.' })
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  domain?: Domain
+
+  @RelationId((one: GalleryLike) => one.domain)
+  domainId?: string
+
+  @ManyToOne(type => GalleryPost, { onDelete: 'CASCADE' })
+  post?: GalleryPost
+
+  @RelationId((one: GalleryLike) => one.post)
+  postId?: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true, description: 'Who likes it.' })
+  user?: User
+
+  @RelationId((one: GalleryLike) => one.user)
+  userId?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true, description: 'When they liked it.' })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  updatedAt?: Date
+
+  @DeleteDateColumn()
+  deletedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((one: GalleryLike) => one.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((one: GalleryLike) => one.updater)
+  updaterId?: string
+}
+
+/**
+ * A calendar event whose gallery is open - opened by a moderator making the event from the gallery, or by the first post
+ * linked to it. Everyone of the domain may post to an open event (ADR-0165 사용자 판정 1).
+ */
+@Entity()
+@Index('ix_gallery_event_0', (one: GalleryEvent) => [one.domain, one.event], {
+  unique: true,
+  where: '"deleted_at" IS NULL'
+})
+@ObjectType({ description: 'A calendar event whose gallery is open to everyone of the domain.' })
+export class GalleryEvent {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID, { description: 'Gallery event id.' })
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  domain?: Domain
+
+  @RelationId((one: GalleryEvent) => one.domain)
+  domainId?: string
+
+  @ManyToOne(type => Event, { onDelete: 'CASCADE' })
+  event?: Event
+
+  @RelationId((one: GalleryEvent) => one.event)
+  eventId?: string
+
+  @CreateDateColumn()
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  updatedAt?: Date
+
+  @DeleteDateColumn()
+  deletedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((one: GalleryEvent) => one.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((one: GalleryEvent) => one.updater)
+  updaterId?: string
+}
+
+/** When a person last opened the gallery - the menu counts the posts that came after. */
+@Entity()
+@Index('ix_gallery_visit_0', (one: GalleryVisit) => [one.domain, one.user], {
+  unique: true,
+  where: '"deleted_at" IS NULL'
+})
+export class GalleryVisit {
+  @PrimaryGeneratedColumn('uuid')
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  domain?: Domain
+
+  @RelationId((one: GalleryVisit) => one.domain)
+  domainId?: string
+
+  @ManyToOne(type => User)
+  user?: User
+
+  @RelationId((one: GalleryVisit) => one.user)
+  userId?: string
+
+  @Column()
+  seenAt: Date
+
+  @CreateDateColumn()
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  updatedAt?: Date
+
+  @DeleteDateColumn()
+  deletedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((one: GalleryVisit) => one.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((one: GalleryVisit) => one.updater)
+  updaterId?: string
+}

package/server/service/gallery/index.ts

@@ -0,0 +1,5 @@
+import { GalleryEvent, GalleryLike, GalleryPost, GalleryVisit } from './gallery'
+import { GalleryResolver } from './gallery-resolver'
+
+export const entities = [GalleryPost, GalleryLike, GalleryEvent, GalleryVisit]
+export const resolvers = [GalleryResolver]

package/server/service/index.ts

@@ -0,0 +1,19 @@
+/* EXPORT ENTITY TYPES */
+export * from './gallery/gallery'
+export * from './gallery/gallery-rules'
+export { GALLERY_REF_TYPE, visiblePost } from './gallery/gallery-service'
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import { entities as GalleryEntities, resolvers as GalleryResolvers } from './gallery'
+
+export const entities = [
+  /* ENTITIES */
+  ...GalleryEntities
+]
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+    ...GalleryResolvers
+  ]
+}

package/server/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig-base.json",
+  "compilerOptions": {
+    "strict": false,
+    "module": "commonjs",
+    "outDir": "../dist-server",
+    "baseUrl": "./"
+  },
+  "include": ["./**/*"],
+  "exclude": ["**/*.spec.ts", "**/*.test.ts"]
+}

package/test/gallery-persistence.test.ts

@@ -0,0 +1,372 @@
+/**
+ * The gallery's doors on sqlite with the real entities (ADR-0165): who sees a post, what a post may hang on, the first
+ * photo of an event told once, likes, tags, the owner's changes, a moderator hiding a post, and the menu's count.
+ *
+ * Reads the built server (`dist-server`) - type-graphql needs tsc's decorator metadata. Storing a photo is
+ * attachment-base's (its own tests); here a photo is a row.
+ */
+import 'reflect-metadata'
+
+const { existsSync } = require('fs')
+const { join } = require('path')
+const { DataSource } = require('typeorm')
+
+/* What notification was asked to send (ADR-0164) - the channels themselves are notification's tests. */
+const told: any[] = []
+jest.mock('@things-factory/notification', () => ({
+  sendNoticeWhenCommitted: (_context: any, notice: any) => told.push(notice),
+  noticeLinkOf: () => undefined
+}))
+
+jest.mock('@things-factory/attachment-base', () => {
+  const actual = jest.requireActual('@things-factory/attachment-base')
+  const shell = jest.requireActual('@things-factory/shell')
+  const repository = (context: any) => shell.getRepository(actual.Attachment, context.state.tx)
+  return {
+    ...actual,
+    createAttachment: async (_: any, { attachment }: any, context: any) => {
+      const file = await attachment.file
+      return repository(context).save({
+        domain: context.state.domain,
+        name: file.filename,
+        mimetype: file.mimetype,
+        encoding: '7bit',
+        refType: attachment.refType,
+        refBy: attachment.refBy,
+        path: `${attachment.refBy}/${file.filename}`,
+        size: '1',
+        category: 'image'
+      })
+    },
+    deleteAttachment: async (_: any, { id }: any, context: any) => !!(await repository(context).delete(id)),
+    deleteAttachmentsByRef: async (_: any, { refBys, refType }: any, context: any) => {
+      for (const refBy of refBys) await repository(context).delete({ refBy, refType })
+      return true
+    }
+  }
+})
+
+const shell = require('@things-factory/shell')
+const authBase = require('@things-factory/auth-base')
+const attachmentBase = require('@things-factory/attachment-base')
+const calendar = require('@things-factory/calendar')
+
+function loadCompiled(modulePath: string): any {
+  const resolved = join(__dirname, '..', 'dist-server', `${modulePath}.js`)
+  if (!existsSync(resolved))
+    throw new Error(`gallery build output is missing: ${resolved}\nBuild it first: npm run build:server`)
+  return require(resolved)
+}
+
+const { GalleryResolver } = loadCompiled('service/gallery/gallery-resolver')
+const { GalleryPost, GalleryLike, GalleryEvent, GalleryVisit } = loadCompiled('service/gallery/gallery')
+
+let dataSource: any
+let domain: any
+let people: Record<string, any>
+const doors = new GalleryResolver()
+
+beforeAll(async () => {
+  dataSource = new DataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new shell.NamingStrategy(),
+    entities: [
+      ...shell.entities,
+      ...authBase.entities,
+      ...attachmentBase.entities,
+      ...calendar.entities,
+      GalleryPost,
+      GalleryLike,
+      GalleryEvent,
+      GalleryVisit
+    ],
+    logging: false
+  })
+  await dataSource.initialize()
+  shell.addDataSource('default', dataSource)
+  shell.addDataSource('tx', dataSource)
+})
+
+afterAll(async () => {
+  if (!dataSource) return
+  shell.removeDataSource('default')
+  shell.removeDataSource('tx')
+  await dataSource.destroy()
+})
+
+/* mod - moderates · kim, lee - employees · left - an account no longer active · outsider - another domain's. */
+beforeEach(async () => {
+  told.length = 0
+  await dataSource.synchronize(true)
+  domain = await dataSource.getRepository(shell.Domain).save({ name: 'gallery', subdomain: 'gallery' })
+  const other = await dataSource.getRepository(shell.Domain).save({ name: 'elsewhere', subdomain: 'elsewhere' })
+  const user = (name: string, domains: any[], status = 'activated') =>
+    dataSource.getRepository(authBase.User).save({ name, email: `${name}@gallery.test`, status, domains })
+  people = {
+    mod: await user('mod', [domain]),
+    kim: await user('kim', [domain]),
+    lee: await user('lee', [domain]),
+    left: await user('left', [domain]),
+    outsider: await user('outsider', [other])
+  }
+})
+
+/** A request of `who` - inside the transaction a door opens; moderating and reading the calendar as given. */
+const as = (who: string, { moderator = false, calendarReader = false } = {}) => ({
+  state: {
+    domain,
+    user: people[who],
+    tx: dataSource.manager,
+    __galleryModerator: Promise.resolve(moderator),
+    __galleryCalendarReader: Promise.resolve(calendarReader)
+  }
+})
+const photo = (filename = 'a.jpg', mimetype = 'image/jpeg') =>
+  Promise.resolve({ filename, mimetype, encoding: '7bit', createReadStream: () => null })
+const post = (who: string, input: any = {}, photos = [photo()]) =>
+  doors.createGalleryPost({ space: 'COMPANY', ...input }, photos, as(who))
+const listed = async (who: string, filter: any = {}, opts: any = {}) =>
+  (await doors.galleryPosts(filter, 0, 60, as(who, opts))).items.map((one: any) => one.caption)
+
+async function eventOf(name: string, attendees: string[] = [], organizer = 'mod') {
+  return dataSource.transaction((tx: any) =>
+    calendar.createEvent(tx, domain, people[organizer], {
+      name,
+      startAt: new Date('2026-10-24T09:00:00Z'),
+      endAt: new Date('2026-10-25T18:00:00Z'),
+      attendees: attendees.map(who => ({ userId: people[who].id }))
+    })
+  )
+}
+
+async function refusal(promise: Promise<unknown>): Promise<string | undefined> {
+  try {
+    await promise
+  } catch (error: any) {
+    return error.extensions?.code
+  }
+  return undefined
+}
+
+describe('who sees a post', () => {
+  it('★ everyone of the domain sees every post, the newest first', async () => {
+    await post('kim', { caption: '첫 사진' })
+    await post('lee', { caption: '내 고양이', space: 'PERSONAL' })
+    expect(await listed('mod')).toEqual(['내 고양이', '첫 사진'])
+    expect(await listed('kim', { space: 'COMPANY' })).toEqual(['첫 사진'])
+    expect(await listed('kim', { authorId: people.lee.id })).toEqual(['내 고양이'])
+    const [first] = (await doors.galleryPosts({}, 0, 1, as('mod'))).items
+    expect((await doors.creator(first))?.name).toBe('lee')
+  })
+
+  it('★ the own gallery of someone who left goes from view; their company posts stay', async () => {
+    await post('left', { caption: '회사 사진' })
+    await post('left', { caption: '내 사진', space: 'PERSONAL' })
+    await dataSource.getRepository(authBase.User).update(people.left.id, { status: 'inactive' })
+    expect(await listed('kim')).toEqual(['회사 사진'])
+  })
+
+  it('★ a hidden post is seen by its owner and the moderators only, and its reason by them only', async () => {
+    const one = await post('kim', { caption: '가릴 사진' })
+    await doors.hideGalleryPost(one.id, '얼굴이 나온 분이 원치 않습니다', as('mod', { moderator: true }))
+    expect(await listed('lee')).toEqual([])
+    expect(await doors.galleryPost(one.id, as('lee'))).toBeUndefined()
+    expect(await listed('kim')).toEqual(['가릴 사진'])
+    expect(await listed('mod', {}, { moderator: true })).toEqual(['가릴 사진'])
+    const seen = await doors.galleryPost(one.id, as('kim'))
+    expect(await doors.hiddenReason(seen, as('kim'))).toBe('얼굴이 나온 분이 원치 않습니다')
+    await doors.unhideGalleryPost(one.id, as('mod', { moderator: true }))
+    expect(await listed('lee')).toEqual(['가릴 사진'])
+  })
+
+  it('★ the owner is told why their post was hidden; a moderator hiding their own is not', async () => {
+    const one = await post('kim')
+    await doors.hideGalleryPost(one.id, '중복', as('mod', { moderator: true }))
+    expect(told.map(one => [one.label, one.receivers.map((r: any) => r.id)])).toEqual([
+      [`gallery hidden ${one.id}`, [people.kim.id]]
+    ])
+    expect(told[0].words('en').body).toBe('Reason: 중복')
+    expect(await refusal(doors.hideGalleryPost(one.id, '  ', as('mod', { moderator: true })))).toBe(
+      'gallery.reason-required'
+    )
+  })
+
+  it('a post of another domain is no post', async () => {
+    const one = await post('kim')
+    const outsider = { state: { ...as('outsider').state, domain: { id: 'elsewhere' } } }
+    expect(await doors.galleryPost(one.id, outsider)).toBeUndefined()
+  })
+})
+
+describe('what a post holds', () => {
+  it('★ photos only, 1 to 20, and no event in a person’s own gallery', async () => {
+    expect(await refusal(post('kim', {}, []))).toBe('gallery.no-photo')
+    expect(await refusal(post('kim', {}, [photo('a.pdf', 'application/pdf')]))).toBe('gallery.not-a-photo')
+    expect(
+      await refusal(
+        post(
+          'kim',
+          {},
+          Array.from({ length: 21 }, () => photo())
+        )
+      )
+    ).toBe('gallery.too-many-photos')
+    const event = await eventOf('가을 워크숍', ['kim'])
+    expect(await refusal(post('kim', { space: 'PERSONAL', eventId: event.id }))).toBe('gallery.event-in-personal')
+    expect(await dataSource.getRepository(GalleryPost).count()).toBe(0)
+  })
+
+  it('keeps the tags as they are kept and the photos in their order', async () => {
+    const one = await post('kim', { caption: '  가을  ', tags: ['#워크숍', '워크숍', ' 팀 '] }, [
+      photo('1.jpg'),
+      photo('2.jpg')
+    ])
+    expect(one).toMatchObject({ caption: '가을', tags: ['워크숍', '팀'], likeCount: 0 })
+    expect((await doors.photos(one, as('kim'))).map((p: any) => p.name)).toEqual(['1.jpg', '2.jpg'])
+  })
+})
+
+describe('an event and its gallery', () => {
+  it('★ posts only to an event one sees - and that post opens it to everyone', async () => {
+    const event = await eventOf('가을 워크숍', ['kim'])
+    expect(await refusal(post('lee', { eventId: event.id }))).toBe('gallery.unknown-event')
+    expect(
+      (await doors.galleryEventChoices(new Date('2026-10-24T12:00:00Z'), as('lee'))).map((one: any) => one.id)
+    ).toEqual([])
+
+    await post('kim', { eventId: event.id, caption: '김의 사진' })
+    expect(await dataSource.getRepository(GalleryEvent).count()).toBe(1)
+    expect(
+      (await doors.galleryEventChoices(new Date('2026-10-24T12:00:00Z'), as('lee'))).map((one: any) => [
+        one.name,
+        one.near
+      ])
+    ).toEqual([['가을 워크숍', true]])
+    await post('lee', { eventId: event.id, caption: '이의 사진' })
+    expect(await listed('mod', { eventId: event.id })).toEqual(['이의 사진', '김의 사진'])
+  })
+
+  it('★ a calendar reader may post to any event', async () => {
+    const event = await eventOf('이사회', [])
+    expect(
+      await refusal(doors.createGalleryPost({ eventId: event.id }, [photo()], as('lee', { calendarReader: true })))
+    ).toBeUndefined()
+  })
+
+  it('★ the first photo is told once - to the people named on it, never the poster', async () => {
+    const event = await eventOf('가을 워크숍', ['kim', 'lee'])
+    await post('kim', { eventId: event.id, caption: '단풍' })
+    await post('lee', { eventId: event.id })
+    expect(told).toHaveLength(1)
+    expect(told[0].receivers.map((r: any) => r.id)).toEqual([people.lee.id])
+    expect(told[0].address).toBe(`gallery-page?event=${event.id}`)
+    expect(told[0].words('en')).toMatchObject({
+      subject: 'Photos of 가을 워크숍 are up',
+      body: 'kim posted the first photos of 가을 워크숍.\n\n단풍'
+    })
+  })
+
+  it('★ an event made from the gallery names nobody - its first photo is told to everyone of the domain who is active', async () => {
+    const made = await doors.createGalleryEvent(
+      { name: '송년회', startAt: new Date('2026-12-20T10:00:00Z'), endAt: new Date('2026-12-20T13:00:00Z') },
+      as('mod', { moderator: true })
+    )
+    await dataSource.getRepository(authBase.User).update(people.left.id, { status: 'inactive' })
+    await post('kim', { eventId: made.id })
+    expect(told[0].receivers.map((r: any) => r.id).sort()).toEqual([people.mod.id, people.lee.id].sort())
+  })
+
+  it('lists the open events with their posts counted and the most liked post’s first photo shown', async () => {
+    const event = await eventOf('가을 워크숍', ['kim', 'lee'])
+    await post('kim', { eventId: event.id }, [photo('k1.jpg'), photo('k2.jpg')])
+    const liked = await post('lee', { eventId: event.id }, [photo('l1.jpg')])
+    await doors.likeGalleryPost(liked.id, true, as('kim'))
+    const [card] = await doors.galleryEvents(as('mod'))
+    expect(card).toMatchObject({ name: '가을 워크숍', postCount: 2 })
+    expect(card.cover.name).toBe('l1.jpg')
+  })
+})
+
+describe('likes', () => {
+  it('★ a like counts once, and is taken back', async () => {
+    const one = await post('kim')
+    expect(await doors.likeGalleryPost(one.id, true, as('lee'))).toMatchObject({ likeCount: 1, liked: true })
+    expect(await doors.likeGalleryPost(one.id, true, as('lee'))).toMatchObject({ likeCount: 1 })
+    await doors.likeGalleryPost(one.id, true, as('mod'))
+    expect((await doors.galleryLikers(one.id, as('kim'))).map((p: any) => p.name).sort()).toEqual(['lee', 'mod'])
+    expect(await doors.likeGalleryPost(one.id, false, as('lee'))).toMatchObject({ likeCount: 1, liked: false })
+    expect((await doors.galleryPost(one.id, as('mod'))).__liked).toBe(true)
+    expect((await doors.galleryPost(one.id, as('lee'))).__liked).toBe(false)
+    expect(told).toHaveLength(0)
+  })
+})
+
+describe('tags', () => {
+  it('★ finds a post by a whole tag, whatever its case', async () => {
+    await post('kim', { caption: 'a', tags: ['Workshop'] })
+    await post('kim', { caption: 'b', tags: ['Workshop2026'] })
+    expect(await listed('lee', { tag: '#workshop' })).toEqual(['a'])
+  })
+
+  it('★ a moderator renames a tag on every post, merging it into one already there', async () => {
+    await post('kim', { caption: 'a', tags: ['워크숍2026', '팀'] })
+    await post('lee', { caption: 'b', tags: ['2026워크숍'] })
+    expect(await doors.renameGalleryTag('워크숍2026', '#2026워크숍', as('mod', { moderator: true }))).toBe(1)
+    expect(await doors.galleryTags(undefined, as('kim'))).toEqual([
+      { tag: '2026워크숍', count: 2 },
+      { tag: '팀', count: 1 }
+    ])
+  })
+})
+
+describe("one's own post", () => {
+  it('★ only its owner changes or deletes it, and at least one photo stays', async () => {
+    const one = await post('kim', { caption: '처음' }, [photo('1.jpg'), photo('2.jpg')])
+    expect(await refusal(doors.updateGalleryPost(one.id, { caption: '남이' }, [], [], as('lee')))).toBe(
+      'gallery.not-yours'
+    )
+    expect(await refusal(doors.deleteGalleryPost(one.id, as('mod', { moderator: true })))).toBe('gallery.not-yours')
+    const photos = await doors.photos(one, as('kim'))
+    expect(
+      await refusal(
+        doors.updateGalleryPost(
+          one.id,
+          {},
+          [],
+          photos.map((p: any) => p.id),
+          as('kim')
+        )
+      )
+    ).toBe('gallery.no-photo')
+    const changed = await doors.updateGalleryPost(
+      one.id,
+      { caption: '고침', tags: ['봄'] },
+      [photo('3.jpg')],
+      [photos[0].id],
+      as('kim')
+    )
+    expect(changed).toMatchObject({ caption: '고침', tags: ['봄'] })
+    expect((await doors.photos(changed, as('kim'))).map((p: any) => p.name)).toEqual(['2.jpg', '3.jpg'])
+
+    expect(await doors.deleteGalleryPost(one.id, as('kim'))).toBe(true)
+    expect(await listed('kim')).toEqual([])
+    expect(await dataSource.getRepository(attachmentBase.Attachment).count()).toBe(0)
+  })
+})
+
+describe('the menu’s count', () => {
+  it('★ counts the posts of others since one last opened the gallery', async () => {
+    await post('kim')
+    await post('lee')
+    expect((await doors.gallerySummary(as('lee'))).fresh).toBe(1)
+    await doors.visitGallery(as('lee'))
+    expect((await doors.gallerySummary(as('lee'))).fresh).toBe(0)
+    /* sqlite keeps a row's creation to the second - the next post comes in a later one. */
+    await new Promise(resolve => setTimeout(resolve, 1100))
+    await post('kim')
+    expect((await doors.gallerySummary(as('lee'))).fresh).toBe(1)
+  })
+})