@sovovs/bycli 2.1.17 → 2.1.19

package/clis/weixin/_wechat/fixtures/collection-detail.json

@@ -0,0 +1,55 @@
+{
+  "base_resp": { "ret": 0, "err_msg": "ok" },
+  "edit_resp": {
+    "id": "900000000000000001",
+    "title": "Synthetic article collection",
+    "desc": "Synthetic fixture; no account data.",
+    "type": 0,
+    "cover_url": "https://example.invalid/article.jpg",
+    "novel_cover_url": "https://example.invalid/novel.jpg",
+    "total": 3,
+    "begin": 0,
+    "create_time": 1700000000,
+    "update_time": 1700003600,
+    "continous_read_on": 1,
+    "is_updating": 1,
+    "is_reverse": 0,
+    "is_numbered": 1,
+    "need_pay": 1,
+    "fee": 6.5,
+    "is_ban": 0,
+    "can_modify_title": 1,
+    "send_quota": 4,
+    "subtype": 2,
+    "theme_color": "#07c160",
+    "update_frequence": { "month": 1 },
+    "continue_flag": 0,
+    "appmsg_infos": [
+      {
+        "appmsgid": 70001,
+        "itemidx": 1,
+        "title": "Synthetic first item",
+        "link": "https://example.invalid/items/1",
+        "cover": "https://example.invalid/items/1.jpg",
+        "create_time": 1700000100,
+        "type": 0,
+        "status": 2,
+        "fail_reason": "",
+        "share_page_type": 1,
+        "is_pay_subscribe": 1,
+        "pay_album_id": "pay-synthetic-1",
+        "wecoin_count": 10
+      },
+      {
+        "appmsgid": "70002",
+        "itemidx": 2,
+        "title": "Synthetic second item",
+        "link": "https://example.invalid/items/2",
+        "cover": "https://example.invalid/items/2.jpg",
+        "create_time": 1700000200,
+        "type": 8,
+        "status": 0
+      }
+    ]
+  }
+}

package/clis/weixin/_wechat/fixtures/collections-list.json

@@ -0,0 +1,38 @@
+{
+  "base_resp": { "ret": 0, "err_msg": "ok" },
+  "list_resp": {
+    "total": 3,
+    "items": [
+      {
+        "id": "900000000000000001",
+        "title": "Synthetic article collection",
+        "type": 0,
+        "total": 12,
+        "uv": 3456,
+        "continous_read_on": 1,
+        "is_updating": 1,
+        "is_ban": 0,
+        "need_pay": 1,
+        "create_time": 1700000000,
+        "update_time": 1700003600,
+        "cover_url": "https://example.invalid/article.jpg",
+        "url": "https://example.invalid/collections/1"
+      },
+      {
+        "id": 9002,
+        "title": "Synthetic video collection",
+        "type": 5,
+        "total": 2,
+        "uv": 40,
+        "continous_read_on": 0,
+        "is_updating": 0,
+        "is_ban": 1,
+        "need_pay": 0,
+        "create_time": 1700010000,
+        "update_time": 1700017200,
+        "cover_url": "https://example.invalid/video.jpg",
+        "url": "https://example.invalid/collections/2"
+      }
+    ]
+  }
+}

package/clis/weixin/_wechat/fixtures/published-page.json

@@ -0,0 +1,6 @@
+{
+  "base_resp": {
+    "ret": 0
+  },
+  "publish_page": "{\"total_count\":2,\"publish_list\":[{\"publish_info\":\"{\\\"msgid\\\":9001,\\\"sent_info\\\":{\\\"time\\\":1786032000},\\\"sent_status\\\":{\\\"succ\\\":120,\\\"fail\\\":2},\\\"appmsg_info\\\":[{\\\"appmsgid\\\":1001,\\\"itemidx\\\":1,\\\"title\\\":\\\"Ontology Weekly\\\",\\\"content_url\\\":\\\"https://mp.weixin.qq.com/s/ontology-weekly\\\",\\\"read_num\\\":88,\\\"like_num\\\":7,\\\"share_num\\\":9,\\\"moment_like_num\\\":4,\\\"comment_num\\\":3,\\\"reprint_num\\\":1,\\\"line_info\\\":{\\\"line_count\\\":5}}]}\"},{\"publish_info\":\"{\\\"msgid\\\":9002,\\\"sent_info\\\":{\\\"time\\\":1785945600},\\\"sent_status\\\":{\\\"succ\\\":90,\\\"fail\\\":0},\\\"appmsg_info\\\":[{\\\"appmsgid\\\":1002,\\\"itemidx\\\":1,\\\"title\\\":\\\"Ontology Weekly Special\\\",\\\"content_url\\\":\\\"https://mp.weixin.qq.com/s/ontology-special?scene=1\\\",\\\"read_num\\\":null,\\\"like_num\\\":null,\\\"share_num\\\":null,\\\"moment_like_num\\\":null,\\\"comment_num\\\":null,\\\"reprint_num\\\":null,\\\"line_info\\\":{}}]}\"}]}"
+}

package/clis/weixin/_wechat/publish-download.js

@@ -0,0 +1,165 @@
+import { constants } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { copyFile, link, mkdir, stat, unlink } from 'node:fs/promises';
+import { basename, extname, resolve } from 'node:path';
+import { CommandExecutionError, TimeoutError } from '@sovovs/bycli/errors';
+
+const DOWNLOAD_SELECTOR = 'a.target_part[href*="download=1"]';
+
+function commandError(message) {
+  return new CommandExecutionError(`WeChat publish-data download ${message}`);
+}
+
+function trustedDownloadLink(link, detailUrl) {
+  let candidate;
+  let detail;
+  try {
+    candidate = new URL(link);
+    detail = new URL(detailUrl);
+  } catch {
+    return false;
+  }
+
+  return candidate.protocol === 'https:'
+    && candidate.hostname === 'mp.weixin.qq.com'
+    && candidate.port === ''
+    && candidate.pathname === '/misc/appmsganalysis'
+    && candidate.searchParams.get('action') === 'detailpage'
+    && candidate.searchParams.get('msgid') === detail.searchParams.get('msgid')
+    && candidate.searchParams.get('publish_date') === detail.searchParams.get('publish_date')
+    && candidate.searchParams.get('download') === '1';
+}
+
+function safeFilename(filename, title) {
+  const fallback = `数据明细（${title}）.xls`;
+  const clean = value => basename(value)
+    .replace(/[<>:"/\\|?*\u0000-\u001f]/g, '_')
+    .trim();
+  let name = clean(filename || fallback) || clean(fallback) || 'publish-data.xls';
+  if (extname(name).toLowerCase() !== '.xls') name += '.xls';
+  return name;
+}
+
+async function publishExclusively(source, outputDir, filename) {
+  const extension = extname(filename);
+  const stem = filename.slice(0, -extension.length);
+  const temporary = resolve(outputDir, `.bycli-publish-data-${randomUUID()}.tmp`);
+  let temporaryCreated = false;
+
+  try {
+    try {
+      await copyFile(source, temporary, constants.COPYFILE_EXCL);
+      temporaryCreated = true;
+    } catch (error) {
+      if (error?.code !== 'EEXIST') {
+        try {
+          await unlink(temporary);
+        } catch {
+          // COPYFILE_EXCL may fail before creating its destination.
+        }
+      }
+      throw commandError('could not stage the downloaded file');
+    }
+
+    for (let index = 0; index <= 9999; index += 1) {
+      const candidate = resolve(outputDir, index === 0 ? filename : `${stem}-${index}${extension}`);
+      try {
+        await link(temporary, candidate);
+        return candidate;
+      } catch (error) {
+        if (error?.code === 'EEXIST') continue;
+        throw commandError('could not publish the downloaded file');
+      }
+    }
+
+    throw commandError('could not allocate a destination filename');
+  } finally {
+    if (temporaryCreated) {
+      try {
+        await unlink(temporary);
+      } catch {
+        // The final hard link, once created, remains a complete valid file.
+      }
+    }
+  }
+}
+
+export async function downloadPublishData(page, options) {
+  if (typeof page?.waitForDownload !== 'function') {
+    throw commandError('requires browser download support');
+  }
+
+  await page.goto(options.detailUrl);
+  const detail = await page.evaluate(() => ({
+    title: document.querySelector('#js_mp_main_content')?.textContent ?? '',
+    link: document.querySelector('a.target_part[href*="download=1"]')?.href ?? '',
+  }));
+
+  if (typeof detail?.title !== 'string' || !detail.title.includes(options.title)) {
+    throw commandError('opened an unexpected article detail page');
+  }
+  if (!trustedDownloadLink(detail?.link, options.detailUrl)) {
+    throw commandError('rejected an untrusted download link');
+  }
+  const trustedUrl = new URL(detail.link);
+  const msgid = trustedUrl.searchParams.get('msgid');
+  const publishDate = trustedUrl.searchParams.get('publish_date');
+  if (!msgid) {
+    throw commandError('rejected a download link without a message id');
+  }
+  if (!publishDate) {
+    throw commandError('rejected a download link without a publish date');
+  }
+
+  const clickedAfterMs = Date.now();
+  await page.click(DOWNLOAD_SELECTOR);
+  const downloaded = await page.waitForDownload(
+    `&msgid=${encodeURIComponent(msgid)}&publish_date=${encodeURIComponent(publishDate)}&`,
+    options.timeoutSeconds * 1000,
+    { includeRecent: true, startedAfterMs: clickedAfterMs },
+  );
+
+  if (!downloaded || downloaded.downloaded !== true) {
+    throw new TimeoutError('Weixin publish-data download', options.timeoutSeconds);
+  }
+  if (typeof downloaded.filename !== 'string'
+    || downloaded.filename.length === 0
+    || downloaded.state !== 'complete'
+    || !['safe', 'accepted'].includes(downloaded.danger)) {
+    throw commandError('returned incomplete or unsafe download metadata');
+  }
+  if (![downloaded.url, downloaded.finalUrl]
+    .some(url => trustedDownloadLink(url, options.detailUrl))) {
+    throw commandError('rejected an unrelated downloaded file');
+  }
+
+  let sourceStat;
+  try {
+    sourceStat = await stat(downloaded.filename);
+  } catch {
+    throw commandError('could not read the downloaded file');
+  }
+  if (!sourceStat.isFile() || sourceStat.size <= 0) {
+    throw commandError('returned an empty downloaded file');
+  }
+
+  const outputDir = resolve(options.outputDir);
+  try {
+    await mkdir(outputDir, { recursive: true });
+  } catch {
+    throw commandError('could not create the output directory');
+  }
+
+  const target = await publishExclusively(
+    downloaded.filename,
+    outputDir,
+    safeFilename(downloaded.filename, options.title),
+  );
+  try {
+    await unlink(downloaded.filename);
+  } catch {
+    // The destination was atomically published; source cleanup is best effort.
+  }
+
+  return { status: 'downloaded', path: target, size: sourceStat.size };
+}

package/clis/weixin/_wechat/publish-records.js

@@ -0,0 +1,304 @@
+import {
+  ArgumentError,
+  AuthRequiredError,
+  CommandExecutionError,
+  EmptyResultError,
+} from '@sovovs/bycli/errors';
+
+const DOMAIN = 'mp.weixin.qq.com';
+const TIME_ZONE = 'Asia/Shanghai';
+const PUBLISH_PATH = '/cgi-bin/appmsgpublish';
+const TRACKING_PARAMS = [
+  'scene',
+  'srcid',
+  'from',
+  'isappinstalled',
+  'sharer_shareinfo',
+  'sharer_shareinfo_first',
+  'exportkey',
+  'pass_ticket',
+  'wx_header',
+];
+
+function commandError(message) {
+  return new CommandExecutionError(`WeChat publish records ${message}`);
+}
+
+function parseJson(value, label) {
+  if (typeof value !== 'string') throw commandError(`returned an invalid ${label}`);
+  try {
+    const parsed = JSON.parse(value);
+    if (!parsed || typeof parsed !== 'object') throw commandError(`returned an invalid ${label}`);
+    return parsed;
+  } catch (error) {
+    if (error instanceof CommandExecutionError) throw error;
+    throw commandError(`returned damaged ${label} JSON`);
+  }
+}
+
+function dateInShanghai(seconds) {
+  if (!Number.isFinite(seconds)) throw commandError('returned a record without a publish date');
+  const date = new Date(Number(seconds) * 1000);
+  if (!Number.isFinite(date.getTime())) throw commandError('returned an invalid publish date');
+  const parts = new Intl.DateTimeFormat('en-US', {
+    timeZone: TIME_ZONE,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+  }).formatToParts(date);
+  const values = Object.fromEntries(parts.map(({ type, value }) => [type, value]));
+  if (!values.year || !values.month || !values.day) {
+    throw commandError('returned an invalid publish date');
+  }
+  return `${values.year}-${values.month}-${values.day}`;
+}
+
+function finiteNumber(value) {
+  return Number.isFinite(value) ? Number(value) : null;
+}
+
+function isDeleted(value) {
+  return value?.is_deleted === 1 || value?.is_delete === 1 || value?.deleted === true;
+}
+
+function routePart(value) {
+  if (Number.isFinite(value)) return String(value);
+  if (typeof value === 'string' && value.trim()) return value.trim();
+  return null;
+}
+
+function decodePublishInfo(value) {
+  const decoded = parseJson(value, 'publish_info');
+  if (!Object.prototype.hasOwnProperty.call(decoded, 'publish_info')) return decoded;
+  const nested = decoded.publish_info;
+  if (typeof nested === 'string') return parseJson(nested, 'nested publish_info');
+  if (nested && typeof nested === 'object') return nested;
+  throw commandError('returned an invalid nested publish_info');
+}
+
+function parseEntry(info, article) {
+  const title = typeof article?.title === 'string' ? article.title.trim() : '';
+  const url = typeof article?.content_url === 'string' ? article.content_url.trim() : '';
+  if (isDeleted(info) || isDeleted(article) || !title || !url) return null;
+
+  const msgid = routePart(article?.appmsgid) ?? routePart(article?.msgid) ?? routePart(info?.msgid);
+  const itemIdx = routePart(article?.itemidx);
+  if (msgid === null || itemIdx === null) {
+    throw commandError('returned an article without a detail route');
+  }
+  const publishedAt = dateInShanghai(info?.sent_info?.time);
+  return {
+    title,
+    publishedAt,
+    url,
+    notified: finiteNumber(info?.sent_status?.succ),
+    failed: finiteNumber(info?.sent_status?.fail),
+    reads: finiteNumber(article?.read_num),
+    likes: finiteNumber(article?.like_num),
+    shares: finiteNumber(article?.share_num),
+    recommends: finiteNumber(article?.moment_like_num),
+    comments: finiteNumber(article?.comment_num),
+    underlines: finiteNumber(article?.line_info?.line_count),
+    reprints: finiteNumber(article?.reprint_num),
+    msgid,
+    itemIdx,
+    publishDate: publishedAt,
+  };
+}
+
+/** @param {unknown} payload */
+export function parsePublishResponse(payload) {
+  if (!payload || typeof payload !== 'object') {
+    throw commandError('returned an unreadable response');
+  }
+  const response = /** @type {Record<string, any>} */ (payload);
+  const ret = response.base_resp?.ret;
+  const message = String(response.base_resp?.err_msg ?? '');
+  const normalizedMessage = message.trim().toLowerCase();
+  if (ret === 200013 && normalizedMessage === 'invalid credential') {
+    throw new AuthRequiredError(DOMAIN, 'WeChat publish credentials have expired');
+  }
+  if (ret !== 0) {
+    throw commandError(`request failed (ret=${String(ret ?? 'unknown')})`);
+  }
+
+  const page = parseJson(response.publish_page, 'publish_page');
+  if (!Array.isArray(page.publish_list)) {
+    throw commandError('returned an invalid publish list');
+  }
+  const entries = [];
+  for (const rawRecord of page.publish_list) {
+    if (!rawRecord || typeof rawRecord !== 'object' || typeof rawRecord.publish_info !== 'string') {
+      throw commandError('returned an invalid publish record');
+    }
+    const info = decodePublishInfo(rawRecord.publish_info);
+    if (!Array.isArray(info.appmsg_info)) {
+      throw commandError('returned an invalid article list');
+    }
+    for (const article of info.appmsg_info) {
+      const entry = parseEntry(info, article);
+      if (entry) entries.push(entry);
+    }
+  }
+
+  return {
+    totalCount: Number.isSafeInteger(page.total_count) ? page.total_count : entries.length,
+    entries,
+  };
+}
+
+export function positiveSafeInteger(value, name, fallback) {
+  const resolved = value ?? fallback;
+  if (!Number.isSafeInteger(resolved) || resolved <= 0) {
+    throw new ArgumentError(`${name} must be a positive safe integer`);
+  }
+  return resolved;
+}
+
+/**
+ * @param {any} page
+ * @param {{token?:string,limit?:number,maxPages?:number,timeout?:number}} [options]
+ */
+export async function collectPublishedRecords(page, options = {}) {
+  const limit = positiveSafeInteger(options.limit, 'limit', 10);
+  const maxPages = positiveSafeInteger(options.maxPages, 'maxPages', 5);
+  const timeout = positiveSafeInteger(options.timeout, 'timeout', 30);
+  if (typeof page?.fetchJson !== 'function') {
+    throw commandError('requires authenticated JSON fetch support');
+  }
+  const seedUrl = new URL(`https://${DOMAIN}${PUBLISH_PATH}`);
+  seedUrl.searchParams.set('sub', 'list');
+  seedUrl.searchParams.set('f', 'json');
+  seedUrl.searchParams.set('begin', '0');
+  seedUrl.searchParams.set('count', '10');
+  seedUrl.searchParams.set('token', String(options.token ?? ''));
+  seedUrl.searchParams.set('lang', 'zh_CN');
+
+  const records = [];
+  const seen = new Set();
+  for (let pageIndex = 0; pageIndex < maxPages && records.length < limit; pageIndex += 1) {
+    const requestUrl = new URL(seedUrl.href);
+    requestUrl.searchParams.set('begin', String(pageIndex * 10));
+    requestUrl.searchParams.set('count', '10');
+    const payload = await page.fetchJson(requestUrl.href, { timeoutMs: timeout * 1000 });
+    const parsed = parsePublishResponse(payload);
+    for (const entry of parsed.entries) {
+      const key = `${entry.msgid}:${entry.itemIdx}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      records.push(entry);
+      if (records.length >= limit) break;
+    }
+    if ((pageIndex + 1) * 10 >= parsed.totalCount) break;
+  }
+
+  if (records.length === 0) {
+    throw new EmptyResultError(
+      'weixin published',
+      'No published records were returned by Weixin.',
+    );
+  }
+  return records.slice(0, limit);
+}
+
+function normalizeTitle(value) {
+  return String(value ?? '').trim().replace(/\s+/g, ' ');
+}
+
+function isCalendarDate(value) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) return false;
+  const [, yearText, monthText, dayText] = match;
+  const year = Number(yearText);
+  const month = Number(monthText);
+  const day = Number(dayText);
+  const date = new Date(0);
+  date.setUTCHours(0, 0, 0, 0);
+  date.setUTCFullYear(year, month - 1, day);
+  return date.getUTCFullYear() === year
+    && date.getUTCMonth() === month - 1
+    && date.getUTCDate() === day;
+}
+
+export function validatePublishDate(value) {
+  if (value === undefined) return undefined;
+  const date = String(value);
+  if (!isCalendarDate(date)) throw new ArgumentError('date must use YYYY-MM-DD');
+  return date;
+}
+
+function parseAbsoluteUrl(value) {
+  try {
+    return new URL(value);
+  } catch {
+    return null;
+  }
+}
+
+function normalizeArticleUrl(value) {
+  const url = parseAbsoluteUrl(value);
+  if (!url
+    || url.protocol !== 'https:'
+    || url.hostname !== DOMAIN
+    || url.port !== ''
+    || url.username !== ''
+    || url.password !== '') return null;
+  url.hash = '';
+  for (const parameter of TRACKING_PARAMS) url.searchParams.delete(parameter);
+  url.searchParams.sort();
+  return url.href;
+}
+
+function ambiguityError(matches) {
+  const choices = matches.slice(0, 5)
+    .map(record => `${record.publishedAt ?? record.publishDate} ${record.title} ${record.url}`)
+    .join('\n');
+  return new ArgumentError(
+    `Multiple published records matched. Use the complete URL or --date.\n${choices}`,
+  );
+}
+
+function uniqueMatch(matches) {
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) throw ambiguityError(matches);
+  return null;
+}
+
+export function matchPublishedRecord(records, query, date) {
+  const text = normalizeTitle(query);
+  if (!text) throw new ArgumentError('query must not be empty');
+  const validatedDate = validatePublishDate(date);
+  const candidates = (Array.isArray(records) ? records : [])
+    .filter(record => validatedDate === undefined || record.publishedAt === validatedDate);
+
+  if (parseAbsoluteUrl(text)) {
+    const normalizedUrl = normalizeArticleUrl(text);
+    if (normalizedUrl) {
+      const matched = uniqueMatch(candidates.filter(record => normalizeArticleUrl(record.url) === normalizedUrl));
+      if (matched) return matched;
+    }
+  } else {
+    const exact = uniqueMatch(candidates.filter(record => normalizeTitle(record.title) === text));
+    if (exact) return exact;
+    const substring = uniqueMatch(candidates.filter(record => normalizeTitle(record.title).includes(text)));
+    if (substring) return substring;
+  }
+
+  throw new EmptyResultError(
+    'weixin download-publish-data',
+    `No published record matched "${text}".`,
+  );
+}
+
+export function buildDetailUrl(record, token) {
+  const parameters = new URLSearchParams({
+    action: 'detailpage',
+    msgid: `${record.msgid}_${record.itemIdx}`,
+    publish_date: record.publishDate,
+    type: 'int',
+    pageVersion: '1',
+    token: String(token),
+    lang: 'zh_CN',
+  });
+  return `https://${DOMAIN}/misc/appmsganalysis?${parameters.toString()}`;
+}

package/clis/weixin/collection-detail.js

@@ -0,0 +1,75 @@
+import { ArgumentError, EmptyResultError } from '@sovovs/bycli/errors';
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { resolveBrowserCredentials } from './_wechat/auth-session.js';
+import { fetchCollectionDetail, findCollectionById } from './_wechat/collections.js';
+
+const SAFE_REFERER = 'https://mp.weixin.qq.com/cgi-bin/appmsgalbum?action=list';
+const PAGE_SIZE = 20;
+
+export const collectionDetailCommand = cli({
+  site: 'weixin',
+  name: 'collection-detail',
+  access: 'read',
+  description: 'Show one WeChat content collection with its settings and items',
+  domain: 'mp.weixin.qq.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  args: [
+    { name: 'collectionId', positional: true, required: true, help: 'Collection ID returned by weixin collections' },
+    { name: 'max-pages', type: 'int', default: 5, help: 'Maximum number of collection pages to scan' },
+  ],
+  columns: [
+    'collectionId', 'title', 'description', 'collectionType', 'coverUrl', 'itemCount',
+    'createdAt', 'updatedAt', 'settingsJson', 'itemsJson',
+  ],
+  func: async (page, args) => {
+    const collectionId = String(args.collectionId ?? '').trim();
+    if (!collectionId) throw new ArgumentError('collectionId is required');
+    const maxPages = args['max-pages'];
+    if (!Number.isSafeInteger(maxPages) || maxPages <= 0) {
+      throw new ArgumentError('max-pages must be a positive safe integer');
+    }
+    const limit = maxPages * PAGE_SIZE;
+    if (!Number.isSafeInteger(limit)) {
+      throw new ArgumentError('max-pages is too large');
+    }
+    const { token } = await resolveBrowserCredentials(page);
+    const found = await findCollectionById({
+      page,
+      token,
+      safeReferer: SAFE_REFERER,
+      collectionId,
+      pageSize: PAGE_SIZE,
+      maxPages,
+    });
+    if (found === null) {
+      throw new EmptyResultError(
+        'weixin collection-detail',
+        `Collection ${collectionId} was not found within the scanned collection pages.`,
+      );
+    }
+    const detail = await fetchCollectionDetail({
+      page,
+      token,
+      safeReferer: SAFE_REFERER,
+      collectionId,
+      collectionType: found.collectionTypeRaw,
+      limit,
+      pageSize: PAGE_SIZE,
+      maxPages,
+    });
+    return [{
+      collectionId: detail.collectionId,
+      title: detail.title,
+      description: detail.description,
+      collectionType: detail.collectionType,
+      coverUrl: detail.coverUrl,
+      itemCount: detail.itemCount,
+      createdAt: detail.createdAt,
+      updatedAt: detail.updatedAt,
+      settingsJson: JSON.stringify(detail.settings),
+      itemsJson: JSON.stringify(detail.items),
+    }];
+  },
+});