@crombolo/server 0.0.0-stage → 0.9.1

package/src/adapters/media.ts

@@ -0,0 +1,347 @@
+/**
+ * The Media section: items stored as documents of the media object type (the
+ * repository takes a kind), never published. An item's file is the path its
+ * `umbracoFile` holds, served from the media root; deleting an item for good
+ * deletes its file too.
+ */
+import type { MediaPort, Principal } from '@crombolo/api-management'
+import {
+  type ContentTypeAggregate,
+  DEFAULT_UPLOAD_SETTINGS,
+  type DocumentAggregate,
+  IMAGE_CROPPER_EDITOR_ALIAS,
+  normaliseUuid,
+  ObjectTypes,
+} from '@crombolo/core'
+import {
+  appendCacheInstruction,
+  ContentTypeRepository,
+  DataTypeRepository,
+  type Db,
+  DocumentRepository,
+  type NodeRow,
+  type NodeSchemaState,
+  type ValueIntake,
+  WriteRejectedError,
+} from '@crombolo/data'
+import { TemporaryFileMissingError } from '../file-intake.ts'
+import type { MediaFileStore } from '../media-files.ts'
+
+/** The file path an item's `umbracoFile` holds, whether an upload or a cropper value. */
+export function mediaFileOf(media: DocumentAggregate): string | null {
+  const value = media.values.find((v) => v.alias === 'umbracoFile')?.value
+  if (typeof value === 'string') return value || null
+  const src = (value as { src?: unknown } | null | undefined)?.src
+  return typeof src === 'string' && src ? src : null
+}
+
+export function createMediaPort(
+  db: Db,
+  files: MediaFileStore,
+  options: {
+    nodeState?: NodeSchemaState
+    nodeId?: string
+    valueIntake?: ValueIntake
+    /** Told after every change, so pages that show media refresh. */
+    onChange?: () => void | Promise<void>
+  } = {},
+): MediaPort {
+  const changed = async () => {
+    await appendCacheInstruction(db, {
+      kind: 'content',
+      payload: { media: true },
+      by: options.nodeId,
+    })
+    await options.onChange?.()
+  }
+  const repo = new DocumentRepository(db, { ...options, kind: 'media' })
+
+  const userIdOf = async (principal: Principal): Promise<number | undefined> => {
+    const rows = await db.query<{ id: number }>('SELECT id FROM user_account WHERE key = ?', [
+      principal.id,
+    ])
+    return rows[0] ? Number(rows[0].id) : undefined
+  }
+  const failure = (error: unknown) => {
+    if (error instanceof WriteRejectedError)
+      return { ok: false as const, reason: error.message, status: 409 }
+    if (error instanceof TemporaryFileMissingError)
+      return { ok: false as const, reason: error.message, status: 400 }
+    throw error
+  }
+  const notFound = (what = 'The media item could not be found.') => ({
+    ok: false as const,
+    reason: what,
+    status: 404,
+  })
+  const tree = async (rows: readonly NodeRow[]) => repo.treeItems(rows)
+  const mediaTypes = new ContentTypeRepository(db, { kind: 'media' })
+  const dataTypes = new DataTypeRepository(db)
+
+  /** Every media type with the data type of its `umbracoFile`, compositions included. */
+  const mediaTypesWithFile = async () => {
+    const all = await mediaTypes.all()
+    const byKey = new Map(all.map((t) => [t.key, t]))
+    const fileOf = (type: ContentTypeAggregate, seen = new Set<string>()): string | undefined => {
+      if (seen.has(type.key)) return undefined
+      seen.add(type.key)
+      const own = type.properties.find((p) => p.alias === 'umbracoFile')?.dataTypeKey
+      if (own) return own
+      for (const c of type.compositions) {
+        const composed = byKey.get(c.contentTypeKey)
+        const found = composed ? fileOf(composed, seen) : undefined
+        if (found) return found
+      }
+      return undefined
+    }
+    const result = []
+    for (const type of all) {
+      const dataTypeKey = fileOf(type)
+      result.push({ type, file: dataTypeKey ? await dataTypes.byKey(dataTypeKey) : undefined })
+    }
+    return result
+  }
+  const allowedExtensions = (values: ReadonlyArray<{ alias: string; value: unknown }>) => {
+    const raw = values.find((v) => v.alias === 'fileExtensions')?.value
+    if (!Array.isArray(raw)) return []
+    return raw
+      .map((e) => (typeof e === 'string' ? e : (e as { value?: unknown })?.value))
+      .filter((e): e is string => typeof e === 'string')
+      .map((e) => e.replace(/^\./, '').toLowerCase())
+  }
+
+  /** Every file in a branch, gathered before the branch is deleted. */
+  const filesIn = async (key: string): Promise<string[]> => {
+    const root = await repo.nodes.byKey(key)
+    if (!root) return []
+    const rows = await db.query<{ unique_id: string }>(
+      'SELECT unique_id FROM node WHERE (id = ? OR path LIKE ?) AND node_object_type = ?',
+      [root.id, `${root.path},%`, ObjectTypes.Media],
+    )
+    const found: string[] = []
+    for (const row of rows) {
+      const media = await repo.byKey(normaliseUuid(String(row.unique_id)))
+      const file = media ? mediaFileOf(media) : null
+      if (file) found.push(file)
+    }
+    return found
+  }
+  const removeBranch = async (key: string) => {
+    const paths = await filesIn(key)
+    const removed = await repo.delete(key)
+    if (removed) {
+      for (const path of paths) await files.remove(path)
+      await changed()
+    }
+    return removed
+  }
+
+  return {
+    byKey: (key) => repo.byKey(key),
+    validate: (input) => repo.validate(input, null),
+
+    async create(input, principal) {
+      try {
+        const created = await repo.create({
+          ...input,
+          componentKey: null,
+          userId: await userIdOf(principal),
+        })
+        await changed()
+        return { ok: true as const, key: created.key }
+      } catch (error) {
+        return failure(error)
+      }
+    },
+
+    async update(key, input, principal) {
+      try {
+        const before = await repo.byKey(key)
+        const updated = await repo.update({
+          ...input,
+          key,
+          componentKey: null,
+          userId: await userIdOf(principal),
+        })
+        if (!updated) return notFound()
+        // A replaced file is no longer anyone's: Umbraco deletes it too.
+        const was = before ? mediaFileOf(before) : null
+        if (was && was !== mediaFileOf(updated)) await files.remove(was)
+        await changed()
+        return { ok: true as const }
+      } catch (error) {
+        return failure(error)
+      }
+    },
+
+    remove: removeBranch,
+    async moveToRecycleBin(key) {
+      const moved = await repo.moveToRecycleBin(key)
+      if (moved) await changed()
+      return moved
+    },
+
+    async move(key, targetKey) {
+      const result = await repo.move(key, targetKey)
+      if (result === 'moved') {
+        await changed()
+        return { ok: true as const }
+      }
+      return result === 'notFound'
+        ? notFound('The media item or target could not be found.')
+        : { ok: false as const, reason: 'A media item cannot move below itself.', status: 400 }
+    },
+
+    async sort(parentKey, sorting) {
+      return (await repo.sort(parentKey, sorting)) === 'sorted'
+        ? { ok: true as const }
+        : notFound('The parent, or one of the items, could not be found under it.')
+    },
+
+    async sortChildrenBy(parentKey, field, direction) {
+      return (await repo.sortChildrenBy(parentKey, field, direction)) === 'sorted'
+        ? { ok: true as const }
+        : notFound()
+    },
+
+    async restore(key, targetKey) {
+      const result = await repo.restore(key, targetKey)
+      if (result === 'restored') {
+        await changed()
+        return { ok: true as const }
+      }
+      return result === 'notFound'
+        ? notFound('The media item is not in the recycle bin.')
+        : {
+            ok: false as const,
+            reason: 'The restore target does not exist or is in the recycle bin.',
+            status: 400,
+          }
+    },
+
+    async emptyRecycleBin() {
+      for (const node of await repo.trashedRoots()) await removeBranch(node.key)
+    },
+
+    originalParent: (key) => repo.originalParent(key),
+    versions: (key) => repo.versions(key),
+    async systemUserKey() {
+      const rows = await db.query<{ key: string }>(
+        'SELECT key FROM user_account ORDER BY id LIMIT 1',
+      )
+      return rows[0] ? normaliseUuid(String(rows[0].key)) : null
+    },
+
+    async treeRoot(paging) {
+      const page = await repo.children(null, paging.skip, paging.take)
+      return { total: page.total, items: await tree(page.items) }
+    },
+    async treeChildren(parentKey, paging) {
+      const page = await repo.children(parentKey, paging.skip, paging.take)
+      return { total: page.total, items: await tree(page.items) }
+    },
+    treeAncestors: async (key) =>
+      tree((await repo.nodes.ancestors(key)).filter((row) => row.objectType === ObjectTypes.Media)),
+    async treeSiblings(target, before, after) {
+      const window = await repo.siblings(target, before, after)
+      if (!window) return undefined
+      return { ...window, items: await tree(window.items) }
+    },
+    async recycleBin(parentKey, paging) {
+      const page = await repo.trashed(parentKey, paging.skip, paging.take)
+      return { total: page.total, items: await tree(page.items) }
+    },
+    async items(keys) {
+      const rows = await Promise.all(keys.map((key) => repo.nodes.byKey(key)))
+      return tree(rows.filter((row): row is NodeRow => row?.objectType === ObjectTypes.Media))
+    },
+    async search(query, options) {
+      const page = await repo.search(query, options)
+      return { total: page.total, items: await tree(page.items) }
+    },
+
+    async collection(parentKey, options) {
+      const children = await repo.children(parentKey, 0, Number.MAX_SAFE_INTEGER)
+      const filter = options.filter?.trim().toLowerCase()
+      const loaded: Array<DocumentAggregate & { sortOrder: number; creator: string | null }> = []
+      for (const node of children.items) {
+        const media = await repo.load(node)
+        if (!media) continue
+        const name = media.variants[0]?.name ?? node.text ?? ''
+        if (filter && !name.toLowerCase().includes(filter)) continue
+        const latest = (await repo.versions(node.key))[0]
+        const creator = latest?.userKey
+          ? ((
+              await db.query<{ user_name: string }>(
+                'SELECT user_name FROM user_account WHERE key = ?',
+                [latest.userKey],
+              )
+            )[0]?.user_name ?? null)
+          : null
+        loaded.push({ ...media, sortOrder: node.sortOrder, creator })
+      }
+      const keyOf = (m: (typeof loaded)[number]): string | number => {
+        const variant = m.variants[0]
+        switch (options.orderBy) {
+          case 'name':
+            return (variant?.name ?? '').toLowerCase()
+          case 'createDate':
+            return variant?.createDate.getTime() ?? 0
+          case 'updateDate':
+            return variant?.updateDate.getTime() ?? 0
+          default:
+            return m.sortOrder
+        }
+      }
+      loaded.sort((a, b) => {
+        const x = keyOf(a)
+        const y = keyOf(b)
+        const order = x < y ? -1 : x > y ? 1 : 0
+        return options.orderDirection === 'Descending' ? -order : order
+      })
+      return {
+        total: loaded.length,
+        items: loaded.slice(options.skip, options.skip + options.take),
+      }
+    },
+
+    async typesForExtension(raw) {
+      const extension = raw.replace(/^\./, '').toLowerCase()
+      const results: Array<{ key: string; name: string; icon: string; matched: boolean }> = []
+      const catchAll: typeof results = []
+      for (const { type, file } of await mediaTypesWithFile()) {
+        if (!file) continue
+        const allowed = allowedExtensions(file.values)
+        const entry = { key: type.key, name: type.name, icon: type.icon }
+        if (file.editorAlias === IMAGE_CROPPER_EDITOR_ALIAS) {
+          if (DEFAULT_UPLOAD_SETTINGS.imageFileTypes.includes(extension))
+            results.push({ ...entry, matched: true })
+        } else if (allowed.includes(extension)) results.push({ ...entry, matched: true })
+        else if (allowed.length === 0) catchAll.push({ ...entry, matched: false })
+      }
+      const seen = new Set(results.map((r) => r.key))
+      return [...results, ...catchAll.filter((c) => !seen.has(c.key))]
+    },
+
+    async folderTypes() {
+      const all = await mediaTypesWithFile()
+      const folders = all
+        .filter(({ type, file }) => !file && type.allowedContentTypes.length > 0)
+        .map(({ type }) => type)
+      if (!folders.some((t) => t.alias === 'Folder')) {
+        const folder = all.find(({ type }) => type.alias === 'Folder')?.type
+        if (folder) folders.push(folder)
+      }
+      return folders.map((t) => ({ key: t.key, name: t.name, icon: t.icon }))
+    },
+
+    async urls(keys) {
+      const result = []
+      for (const key of keys) {
+        const media = await repo.byKey(key)
+        if (media) result.push({ key: media.key, url: mediaFileOf(media) })
+      }
+      return result
+    },
+  }
+}

package/src/adapters/member-groups.ts

@@ -0,0 +1,90 @@
+/**
+ * Member groups are plain `node` rows with the MemberGroup object type — no
+ * table of their own, so this is the node repository with a name-uniqueness
+ * rule on top, as Umbraco's `MemberGroupService` has.
+ */
+import type { MemberGroupPort, MemberGroupStatus } from '@crombolo/api-management'
+import { ObjectTypes, type Page, SystemNodes } from '@crombolo/core'
+import { type Db, NodeRepository } from '@crombolo/data'
+
+const TYPE = ObjectTypes.MemberGroup
+
+export function createMemberGroupPort(db: Db): MemberGroupPort {
+  const nodes = new NodeRepository(db)
+
+  const named = async (name: string): Promise<{ key: string } | undefined> => {
+    const rows = await db.query<{ unique_id: string }>(
+      'SELECT n.unique_id FROM node n WHERE n.node_object_type = ? AND n.text = ?',
+      [TYPE, name],
+    )
+    const key = rows[0]?.unique_id
+    return key ? { key: String(key) } : undefined
+  }
+
+  const page = async (skip: number, take: number): Promise<Page<{ id: string; name: string }>> => {
+    const result = await nodes.roots(TYPE, skip, take)
+    return {
+      total: result.total,
+      items: result.items.map((row) => ({ id: row.key, name: row.text ?? '' })),
+    }
+  }
+
+  return {
+    list: (paging) => page(paging.skip, paging.take),
+
+    async byKey(key) {
+      const node = await nodes.byKey(key)
+      if (!node || node.objectType !== TYPE) return undefined
+      return { id: node.key, name: node.text ?? '' }
+    },
+
+    async items(keys) {
+      const rows = await nodes.byKeys(keys)
+      return rows
+        .filter((row) => row.objectType === TYPE)
+        .map((row) => ({ id: row.key, name: row.text ?? '', flags: [] }))
+    },
+
+    async tree(paging) {
+      const result = await page(paging.skip, paging.take)
+      return {
+        total: result.total,
+        // A flat list: no group ever has children, and none has a parent.
+        items: result.items.map((item) => ({
+          ...item,
+          parent: null,
+          hasChildren: false,
+          flags: [],
+        })),
+      }
+    },
+
+    async create(input) {
+      if (await named(input.name)) return { status: 'duplicate-name' }
+      const node = await nodes.create({
+        key: input.key,
+        parentId: SystemNodes.Root,
+        objectType: TYPE,
+        text: input.name,
+      })
+      return { status: 'ok', key: node.key }
+    },
+
+    async rename(key, name): Promise<MemberGroupStatus> {
+      const node = await nodes.byKey(key)
+      if (!node || node.objectType !== TYPE) return 'not-found'
+      const clash = await named(name)
+      if (clash && clash.key !== node.key) return 'duplicate-name'
+      await nodes.rename(node.id, name)
+      return 'ok'
+    },
+
+    async remove(key): Promise<MemberGroupStatus> {
+      const node = await nodes.byKey(key)
+      if (!node || node.objectType !== TYPE) return 'not-found'
+      await db.exec('DELETE FROM member_group_member WHERE member_group_id = ?', [node.id])
+      await nodes.delete(node.id)
+      return 'ok'
+    },
+  }
+}

package/src/adapters/members.ts

@@ -0,0 +1,261 @@
+/**
+ * The Members section.
+ *
+ * A member is a content node with a sign-in facet, so the content half of a save
+ * is the same machinery documents use and the facet half is the `member` row.
+ * Three things are ours to enforce here rather than in the repository:
+ *
+ * - **Uniqueness.** Umbraco refuses a duplicate username or e-mail; the columns
+ *   are case-insensitive in both dialects, so "A@b.com" and "a@b.com" clash.
+ * - **Sensitive values.** A member property marked sensitive is withheld from a
+ *   user outside the Sensitive data group, compositions included.
+ * - **Passwords.** Plaintext arrives here and nowhere deeper; a change of one
+ *   rotates the security stamp, which ends the member's sessions.
+ *
+ * `kind` is always `Default`: Umbraco reports `Api` only for a Delivery API
+ * client-credentials member and `ExternalOnly` only for one in its lightweight
+ * external-member table, and we have neither.
+ */
+import type {
+  MemberFilterCriteria,
+  MemberItem,
+  MemberPort,
+  MemberResponse,
+  Principal,
+  SaveMember,
+} from '@crombolo/api-management'
+import { hashPassword, passwordConfigJson, verifyPassword } from '@crombolo/auth'
+import {
+  type ContentTypeAggregate,
+  hasAccessToSensitiveData,
+  normaliseUuid,
+  type Page,
+} from '@crombolo/core'
+import {
+  ContentTypeRepository,
+  type Db,
+  type DocumentRepositoryOptions,
+  type MemberCredentials,
+  MemberRepository,
+  type ValueIntake,
+  WriteRejectedError,
+} from '@crombolo/data'
+
+export interface MemberPortOptions extends DocumentRepositoryOptions {
+  valueIntake?: ValueIntake
+  /** How many failed sign-ins lock an account out; Umbraco's default is 5. */
+  maxFailedPasswordAttempts?: number
+}
+
+const notFound = () => ({
+  ok: false as const,
+  reason: 'The member could not be found.',
+  status: 404,
+})
+
+export function createMemberPort(db: Db, options: MemberPortOptions = {}): MemberPort {
+  const members = new MemberRepository(db, options)
+  const memberTypes = new ContentTypeRepository(db, { kind: 'member' })
+
+  const userIdOf = async (principal: Principal): Promise<number | undefined> => {
+    const rows = await db.query<{ id: number }>('SELECT id FROM user_account WHERE key = ?', [
+      principal.id,
+    ])
+    return rows[0] ? Number(rows[0].id) : undefined
+  }
+
+  /** Sensitive aliases of a member type, following its compositions. */
+  const sensitiveAliases = async (typeKey: string): Promise<Set<string>> => {
+    const all = await memberTypes.all()
+    const byKey = new Map(all.map((type) => [normaliseUuid(type.key), type]))
+    const aliases = new Set<string>()
+    const walk = (type: ContentTypeAggregate | undefined, seen = new Set<string>()) => {
+      if (!type || seen.has(type.key)) return
+      seen.add(type.key)
+      for (const property of type.properties)
+        if (property.isSensitive === true) aliases.add(property.alias)
+      for (const composition of type.compositions)
+        walk(byKey.get(normaliseUuid(composition.contentTypeKey)), seen)
+    }
+    walk(byKey.get(normaliseUuid(typeKey)))
+    return aliases
+  }
+
+  const toResponse = async (
+    member: MemberCredentials,
+    viewer: Principal,
+  ): Promise<MemberResponse | undefined> => {
+    const content = await members.content.byKey(member.key)
+    if (!content) return undefined
+    const withheld = hasAccessToSensitiveData(viewer.groups)
+      ? new Set<string>()
+      : await sensitiveAliases(member.contentTypeKey)
+    return {
+      id: member.key,
+      email: member.email,
+      username: member.username,
+      memberType: {
+        id: member.contentTypeKey,
+        icon: member.contentTypeIcon ?? 'icon-user',
+        collection: content.contentTypeCollectionKey
+          ? { id: content.contentTypeCollectionKey }
+          : null,
+      },
+      isApproved: member.isApproved,
+      isLockedOut: member.isLockedOut,
+      // No second factor is offered yet, so no member has one enabled.
+      isTwoFactorEnabled: false,
+      failedPasswordAttempts: member.failedPasswordAttempts,
+      lastLoginDate: member.lastLoginDate?.toISOString() ?? null,
+      lastLockoutDate: member.lastLockoutDate?.toISOString() ?? null,
+      lastPasswordChangeDate: member.lastPasswordChangeDate?.toISOString() ?? null,
+      groups: await members.groupKeys(member.key),
+      kind: 'Default',
+      profileData: null,
+      flags: [],
+      values: content.values
+        .filter((value) => !withheld.has(value.alias))
+        .map((value) => ({
+          alias: value.alias,
+          culture: value.culture,
+          segment: value.segment,
+          value: value.value,
+          editorAlias: value.editorAlias ?? '',
+        })),
+      variants: content.variants.map((variant) => ({
+        culture: variant.culture,
+        segment: variant.segment,
+        name: variant.name,
+        createDate: variant.createDate.toISOString(),
+        updateDate: variant.updateDate.toISOString(),
+      })),
+    }
+  }
+
+  const toItem = (member: MemberCredentials): MemberItem => ({
+    id: member.key,
+    memberType: { id: member.contentTypeKey, icon: member.contentTypeIcon ?? 'icon-user' },
+    variants: [{ name: member.name, culture: null }],
+    kind: 'Default',
+    flags: [],
+  })
+
+  const contentOf = (input: SaveMember, contentTypeKey: string) => ({
+    key: input.key,
+    contentTypeKey,
+    componentKey: null,
+    parentKey: null,
+    values: input.values,
+    variants:
+      input.variants.length > 0
+        ? input.variants
+        : [{ culture: null, segment: null, name: input.username }],
+  })
+
+  /** Umbraco's duplicate checks, which the columns' case-insensitivity decides. */
+  const duplicate = async (input: SaveMember, exceptKey?: string) => {
+    if (await members.taken('username', input.username, exceptKey))
+      return {
+        ok: false as const,
+        reason: 'Another member already uses this username.',
+        status: 400,
+      }
+    if (await members.taken('email', input.email, exceptKey))
+      return {
+        ok: false as const,
+        reason: 'Another member already uses this e-mail address.',
+        status: 400,
+      }
+    return undefined
+  }
+
+  const failure = (error: unknown) => {
+    if (error instanceof WriteRejectedError)
+      return { ok: false as const, reason: error.message, status: 409 }
+    throw error
+  }
+
+  return {
+    async byKey(key, viewer) {
+      const member = await members.byKey(key)
+      return member ? toResponse(member, viewer) : undefined
+    },
+
+    validate: (input) => members.content.validate(contentOf(input, input.memberTypeKey), null),
+
+    async create(input, principal) {
+      const type = await memberTypes.byKey(input.memberTypeKey)
+      if (!type)
+        return { ok: false as const, reason: 'The member type could not be found.', status: 404 }
+      const clash = await duplicate(input)
+      if (clash) return clash
+      try {
+        const created = await members.create(
+          { ...contentOf(input, type.key), userId: await userIdOf(principal) },
+          {
+            email: input.email,
+            username: input.username,
+            isApproved: input.isApproved,
+            isLockedOut: input.isLockedOut,
+            passwordHash: input.password ? await hashPassword(input.password) : null,
+            passwordConfig: input.password ? passwordConfigJson() : null,
+            groupKeys: input.groupKeys ?? [],
+          },
+        )
+        return { ok: true as const, key: created.key }
+      } catch (error) {
+        return failure(error)
+      }
+    },
+
+    async update(key, input, principal) {
+      const existing = await members.byKey(key)
+      if (!existing) return notFound()
+      const clash = await duplicate(input, key)
+      if (clash) return clash
+      // Umbraco requires the current password only when the editor supplies one;
+      // an administrator changing another member's password does not.
+      if (input.oldPassword && !(await verifyPassword(input.oldPassword, existing.passwordHash)))
+        return { ok: false as const, reason: 'The current password is not correct.', status: 400 }
+      try {
+        const updated = await members.update(
+          key,
+          { ...contentOf(input, existing.contentTypeKey), userId: await userIdOf(principal) },
+          {
+            email: input.email,
+            username: input.username,
+            isApproved: input.isApproved,
+            isLockedOut: input.isLockedOut,
+            passwordHash: input.password ? await hashPassword(input.password) : undefined,
+            passwordConfig: input.password ? passwordConfigJson() : undefined,
+            groupKeys: input.groupKeys,
+          },
+        )
+        return updated ? { ok: true as const } : notFound()
+      } catch (error) {
+        return failure(error)
+      }
+    },
+
+    remove: (key) => members.delete(key),
+
+    async filter(criteria: MemberFilterCriteria, viewer): Promise<Page<MemberResponse>> {
+      const page = await members.filter(criteria)
+      const items: MemberResponse[] = []
+      for (const member of page.items) {
+        const response = await toResponse(member, viewer)
+        if (response) items.push(response)
+      }
+      return { total: page.total, items }
+    },
+
+    async items(keys) {
+      return (await members.items(keys)).map(toItem)
+    },
+
+    async search(query, paging) {
+      const page = await members.search(query, paging)
+      return { total: page.total, items: page.items.map(toItem) }
+    },
+  }
+}