nnbb 0.0.1

package/lib/notion/getAllCategories.ts

@@ -0,0 +1,51 @@
+import type { CategoryInfo, PageInfo, SelectOption } from './types';
+
+/**
+ * 获取所有文章的标签
+ * @param allPosts
+ * @param sliceCount 默认截取数量为12，若为0则返回全部
+ * @param tagOptions tags的下拉选项
+ * @returns {CategoryInfo[]}
+ */
+
+/**
+ * 获取所有文章的分类
+ * @param allPosts
+ * @returns {Promise<{}|*[]>}
+ */
+export function getAllCategories(
+  publishedPosts: PageInfo[],
+  categoryOptions: SelectOption[],
+  sliceCount = 0,
+): CategoryInfo[] {
+  // 计数
+  const countMap: { [key: string]: number } = {};
+  publishedPosts.forEach(({ category }) => {
+    if (!category) return;
+    if (category in countMap) {
+      countMap[category]++;
+    } else {
+      countMap[category] = 1;
+    }
+  });
+  const list: CategoryInfo[] = [];
+  for (const categoryOption of categoryOptions) {
+    const count = countMap[categoryOption.value];
+    if (count) {
+      list.push({
+        id: categoryOption.id,
+        name: categoryOption.value,
+        color: categoryOption.color,
+        count,
+      });
+    }
+  }
+
+  // 按照数量排序
+  // list.sort((a, b) => b.count - a.count)
+  if (sliceCount && sliceCount > 0) {
+    return list.slice(0, sliceCount);
+  } else {
+    return list;
+  }
+}

package/lib/notion/getAllPageIds.ts

@@ -0,0 +1,51 @@
+import type { CollectionQueryResult, CollectionViewMap } from './types';
+
+type Query = {
+  [collectionId: string]: {
+    [collectionViewId: string]: CollectionQueryResult;
+  };
+};
+
+export default function getAllPageIds(
+  collectionQuery: Query,
+  collectionId: string | null,
+  collectionView: CollectionViewMap,
+  viewIds: string[],
+) {
+  if (!collectionQuery && !collectionView) {
+    return [];
+  }
+  // 优先按照第一个视图排序
+  let pageIds: string[] = [];
+  try {
+    if (viewIds && viewIds.length > 0 && collectionId) {
+      const ids =
+        collectionQuery[collectionId][viewIds[0]]?.collection_group_results
+          ?.blockIds || [];
+      for (const id of ids) {
+        pageIds.push(id);
+      }
+    }
+  } catch (error) {
+    console.log(error);
+  }
+
+  // 否则按照数据库原始排序
+  if (
+    pageIds.length === 0 &&
+    collectionQuery &&
+    Object.values(collectionQuery).length > 0 &&
+    collectionId
+  ) {
+    const pageSet = new Set<string>();
+    Object.values(collectionQuery[collectionId]).forEach((view) => {
+      view?.blockIds?.forEach((id) => pageSet.add(id)); // group视图
+      view?.collection_group_results?.blockIds?.forEach((id) =>
+        pageSet.add(id),
+      ); // table视图
+    });
+    pageIds = [...pageSet];
+    // console.log('PageIds: 从collectionQuery获取', collectionQuery, pageIds.length)
+  }
+  return pageIds;
+}

package/lib/notion/getAllPosts.js

@@ -0,0 +1,68 @@
+import BLOG from '@/blog.config';
+import getAllPageIds from './getAllPageIds';
+import getPageProperties from './getPageProperties';
+import { getNotionPageData } from '@/lib/notion/getNotionData';
+import { delCacheData } from '@/lib/cache/cache_manager';
+
+/**
+ * 获取所有文章列表
+ * @param notionPageData
+ * @param from
+ * @param pageType 页面类型数组 ['Post','Page']
+ * @returns {Promise<*[]>}
+ */
+export async function getAllPosts({ notionPageData, from, pageType }) {
+  if (!notionPageData) {
+    notionPageData = await getNotionPageData({ from });
+  }
+  if (!notionPageData) {
+    return [];
+  }
+
+  const {
+    block,
+    schema,
+    collectionQuery,
+    collectionId,
+    collectionView,
+    viewIds,
+  } = notionPageData;
+  const data = [];
+  const pageIds = getAllPageIds(
+    collectionQuery,
+    collectionId,
+    collectionView,
+    viewIds,
+  );
+  for (let i = 0; i < pageIds.length; i++) {
+    const id = pageIds[i];
+    const value = block[id]?.value;
+    if (!value) {
+      continue;
+    }
+    const properties = (await getPageProperties(id, block, schema)) || null;
+    data.push(properties);
+  }
+
+  // remove all the the items doesn't meet requirements
+  const posts = data.filter((post) => {
+    return (
+      post.title &&
+      post?.status?.[0] === 'Published' &&
+      pageType.indexOf(post?.type?.[0]) > -1
+    );
+  });
+
+  if (!posts || posts.length === 0) {
+    const cacheKey = 'page_block_' + BLOG.NOTION_PAGE_ID;
+    await delCacheData(cacheKey);
+  }
+
+  // Sort by date
+  if (BLOG.POSTS_SORT_BY === 'date') {
+    posts.sort((a, b) => {
+      return b?.publishDate - a?.publishDate;
+    });
+  }
+  return posts;
+}

package/lib/notion/getAllTags.ts

@@ -0,0 +1,43 @@
+import { isIterable } from '../utils';
+import type { PageInfo, SelectOption, TagInfo } from './types';
+
+/**
+ * 获取所有文章的标签
+ * @param allPosts
+ * @param sliceCount 默认截取数量为12，若为0则返回全部
+ * @param tagOptions tags的下拉选项
+ * @returns {Promise<{}|*[]>}
+ */
+export function getAllTags(
+  publishedPosts: PageInfo[],
+  tagOptions: SelectOption[],
+  sliceCount = 0,
+): TagInfo[] {
+  // 计数
+  const tags = publishedPosts?.map((p) => p.tags).flat();
+  const countMap: { [key: string]: number } = {};
+  tags.forEach((tag) => {
+    if (tag in countMap) {
+      countMap[tag]++;
+    } else {
+      countMap[tag] = 1;
+    }
+  });
+  const list: TagInfo[] = [];
+  if (isIterable(tagOptions)) {
+    tagOptions.forEach((tag) => {
+      const count = countMap[tag.value];
+      if (count) {
+        list.push({ id: tag.id, name: tag.value, color: tag.color, count });
+      }
+    });
+  }
+
+  // 按照数量排序
+  // list.sort((a, b) => b.count - a.count)
+  if (sliceCount && sliceCount > 0) {
+    return list.slice(0, sliceCount);
+  } else {
+    return list;
+  }
+}

package/lib/notion/getNotionData.ts

@@ -0,0 +1,340 @@
+import BLOG from '@/blog.config';
+import { getDataFromCache, setDataToCache } from '@/lib/cache/cacheManager';
+import { getPostBlocks } from '@/lib/notion/getPostBlocks';
+import { idToUuid } from 'notion-utils';
+import { getAllCategories } from './getAllCategories';
+import getAllPageIds from './getAllPageIds';
+import { getAllTags } from './getAllTags';
+import getPageProperties from './getPageProperties';
+import { mapImgUrl, compressImage } from './mapImage';
+import dayjs from 'dayjs';
+
+import type {
+  CustomNav,
+  PageInfo,
+  CollectionPropertySchemaMap,
+  SelectOption,
+  SiteInfo,
+  DataBaseInfo,
+  PatchedCollection,
+} from './types';
+
+/**
+ * 获取博客数据
+ * @param {*} pageId
+ * @param {*} from
+ * @returns
+ *
+ */
+export async function getGlobalData(from: string) {
+  // 从notion获取
+  const data = await getNotionPageData(idToUuid(BLOG.NOTION_PAGE_ID), from);
+  return data;
+  // const db = cloneDeep(data);
+  // 不返回的敏感数据
+  // delete db.block;
+  // delete db.schema;
+  // delete db.rawMetadata;
+  // delete db.pageIds;
+  // delete db.viewIds;
+  // delete db.collection;
+  // delete db.collectionQuery;
+  // delete db.collectionId;
+  // delete db.collectionView;
+  // return db;
+}
+
+/**
+ * 获取最新文章 根据最后修改时间倒序排列
+ * @param {*}} param0
+ * @returns
+ */
+function getLatestPosts(
+  allPages: PageInfo[],
+  latestPostCount: number,
+): PageInfo[] {
+  const allPosts = allPages.filter(
+    (page) => page.type === 'Post' && page.status === 'Published',
+  );
+
+  const latestPosts = Object.create(allPosts).sort(
+    (a: PageInfo, b: PageInfo) => {
+      const dateA = dayjs(a?.lastEditedDate || a?.publishDate);
+      const dateB = dayjs(b?.lastEditedDate || b?.publishDate);
+      return dateB.isAfter(dateA) ? 1 : -1;
+    },
+  );
+  return latestPosts.slice(0, latestPostCount);
+}
+
+/**
+ * 获取指定notion的collection数据
+ * @param pageId
+ * @param from 请求来源
+ * @returns {Promise<JSX.Element|*|*[]>}
+ */
+export async function getNotionPageData(
+  pageId: string,
+  from: string,
+): Promise<DataBaseInfo> {
+  // 尝试从缓存获取
+  const cacheKey = 'page_block_' + pageId;
+  const data = await getDataFromCache<DataBaseInfo>(cacheKey);
+  if (data && data.pageIds?.length > 0) {
+    console.log('[缓存]:', `from:${from}`, `root-page-id:${pageId}`);
+    return data;
+  }
+  const dataBaseInfo = await getDataBaseInfoByNotionAPI(pageId, from);
+  // 存入缓存
+  if (dataBaseInfo) {
+    await setDataToCache(cacheKey, dataBaseInfo);
+  }
+  return dataBaseInfo;
+}
+
+/**
+ * 获取用户自定义单页菜单
+ * @param notionPageData
+ * @returns {Promise<[]|*[]>}
+ */
+function getCustomNav(allPages: PageInfo[]) {
+  const customNav: CustomNav[] = [];
+  if (allPages && allPages.length > 0) {
+    allPages.forEach((p: PageInfo) => {
+      if (p?.slug?.indexOf('http') === 0) {
+        customNav.push({
+          icon: p.icon || '',
+          name: p.title,
+          to: p.slug,
+          target: '_blank',
+          show: true,
+        });
+      } else {
+        customNav.push({
+          icon: p.icon || '',
+          name: p.title,
+          to: '/' + p.slug,
+          target: '_self',
+          show: true,
+        });
+      }
+    });
+  }
+  return customNav;
+}
+
+/**
+ * 获取标签选项
+ * @param schemaMap
+ * @returns {undefined}
+ */
+function getTagOptions(schemaMap: CollectionPropertySchemaMap): SelectOption[] {
+  if (!schemaMap) return [];
+  const tagSchema = Object.values(schemaMap).find(
+    (e) => e.name === BLOG.NOTION_PROPERTY_NAME.tags,
+  );
+  return tagSchema?.options || [];
+}
+
+/**
+ * 获取分类选项
+ * @param schemaMap
+ * @returns {{}|*|*[]}
+ */
+function getCategoryOptions(
+  schemaMap: CollectionPropertySchemaMap,
+): SelectOption[] {
+  if (!schemaMap) return [];
+  const categorySchema = Object.values(schemaMap).find(
+    (e) => e.name === BLOG.NOTION_PROPERTY_NAME.category,
+  );
+  return categorySchema?.options || [];
+}
+
+/**
+ * 站点信息
+ * @param notionPageData
+ * @param from
+ * @returns {Promise<{title,description,pageCover,icon}>}
+ */
+function getSiteInfo(collection: PatchedCollection): SiteInfo {
+  const title = collection.name[0][0] || BLOG.TITLE;
+  const description = collection.description
+    ? Object.assign(collection).description[0][0]
+    : BLOG.DESCRIPTION;
+  const pageCover = collection.cover
+    ? mapImgUrl(collection.cover, collection, 'collection')
+    : BLOG.HOME_BANNER_IMAGE;
+  let icon = collection?.icon
+    ? mapImgUrl(collection?.icon, collection, 'collection')
+    : BLOG.AVATAR;
+
+  // 用户头像压缩一下
+  icon = compressImage(icon);
+
+  // 站点图标不能是emoji情
+  const emojiPattern = /\uD83C[\uDF00-\uDFFF]|\uD83D[\uDC00-\uDE4F]/g;
+  if (!icon || emojiPattern.test(icon)) {
+    icon = BLOG.AVATAR;
+  }
+  return { title, description, pageCover, icon };
+}
+
+/**
+ * 获取公告
+ */
+async function getNotice(post: PageInfo) {
+  if (!post) {
+    return null;
+  }
+
+  post.blockMap = await getPostBlocks(post.id, 'data-notice');
+  return post;
+}
+
+/**
+ * 调用NotionAPI获取Page数据
+ * @returns {Promise<JSX.Element|null|*>}
+ */
+async function getDataBaseInfoByNotionAPI(
+  pageId: string,
+  from: string,
+): Promise<DataBaseInfo> {
+  const pageRecordMap = await getPostBlocks(pageId, from);
+  if (!pageRecordMap) {
+    console.error('can`t get Notion Data ; Which id is: ', pageId);
+    throw Error('can`t get Notion Data');
+    // return {};
+  }
+  const blockMap = pageRecordMap.block || {};
+  const rawBlockData = blockMap[pageId].value;
+  // Check Type Page-Database和Inline-Database
+  if (
+    rawBlockData.type !== 'collection_view_page' &&
+    rawBlockData.type !== 'collection_view'
+  ) {
+    console.error(`pageId "${pageId}" is not a database`);
+    throw Error(`pageId "${pageId}" is not a database`);
+    // return EmptyData(pageUuid);
+  }
+  const collection = Object.values(pageRecordMap.collection)[0].value || {};
+  const siteInfo = getSiteInfo(collection as PatchedCollection);
+
+  const collectionId = rawBlockData.collection_id || null;
+  const viewIds = rawBlockData.view_ids;
+
+  const collectionQuery = pageRecordMap.collection_query;
+  const collectionView = pageRecordMap.collection_view;
+
+  const schemaMap = collection.schema;
+  const tagOptions = getTagOptions(schemaMap);
+  const categoryOptions = getCategoryOptions(schemaMap);
+
+  const pageIds = getAllPageIds(
+    collectionQuery,
+    collectionId,
+    collectionView,
+    viewIds,
+  );
+  if (pageIds.length === 0) {
+    console.error(
+      '获取到的文章列表为空，请检查notion模板',
+      collectionQuery,
+      collection,
+      collectionView,
+      viewIds,
+      pageRecordMap,
+    );
+  }
+
+  const pageProperties: PageInfo[] = (
+    await Promise.all(
+      pageIds.map(async (pageId) => {
+        if (blockMap[pageId]?.value) {
+          try {
+            const properties = await getPageProperties(
+              pageId,
+              blockMap,
+              schemaMap,
+            );
+            return properties || null;
+          } catch (error) {
+            console.error(
+              `Error getting properties for page ${pageId}:`,
+              error,
+            );
+            return null;
+          }
+        }
+        return null;
+      }),
+    )
+  ).filter(Boolean) as PageInfo[];
+
+  // 查找所有的Post和Page
+  const allPages: PageInfo[] = [];
+  const publishedPosts: PageInfo[] = [];
+
+  pageProperties.forEach((page) => {
+    if (page.type === 'Post' && page.status === 'Published') {
+      publishedPosts.push(page);
+    }
+    if (
+      page &&
+      page.slug &&
+      !page.slug?.startsWith('http') &&
+      (page.status === 'Invisible' || page.status === 'Published')
+    ) {
+      allPages.push(page);
+    }
+  });
+
+  // Sort by date
+  if (BLOG.POSTS_SORT_BY === 'date') {
+    allPages.sort((a, b) => {
+      return dayjs(b.publishDate).isAfter(a.publishDate) ? 1 : -1;
+    });
+  }
+
+  const notice = await getNotice(
+    pageProperties.filter(
+      (post) =>
+        post &&
+        post.type &&
+        post.type === 'Notice' &&
+        post.status &&
+        post.status === 'Published',
+    )[0],
+  );
+  const categories = getAllCategories(publishedPosts, categoryOptions);
+  const tags = getAllTags(publishedPosts, tagOptions);
+  // 旧的菜单
+  const customNav = getCustomNav(
+    pageProperties.filter(
+      (post) => post?.type === 'Page' && post.status === 'Published',
+    ),
+  );
+
+  const latestPosts = getLatestPosts(allPages, 6);
+
+  return {
+    notice,
+    siteInfo,
+    allPages,
+    collection,
+    collectionQuery,
+    collectionId,
+    collectionView,
+    viewIds,
+    block: blockMap,
+    schema: schemaMap,
+    tagOptions: tags,
+    categoryOptions: categories,
+    rawMetadata: rawBlockData,
+    customNav,
+    postCount: publishedPosts.length,
+    publishedPosts,
+    pageIds,
+    latestPosts,
+  };
+}

package/lib/notion/getPageInfoOfPostPage.ts

@@ -0,0 +1,58 @@
+import BLOG from '@/blog.config';
+import { idToUuid } from 'notion-utils';
+import { getPostBlocks } from './getPostBlocks';
+import { defaultMapImageUrl } from 'react-notion-x';
+import dayjs from 'dayjs';
+
+import {
+  Block,
+  PageInfo,
+  PagePropertiesType,
+  PagePropertiesStatus,
+} from './types';
+
+/**
+ * formate from postBlock to pageInfo
+ * @param {*} pageId
+ * @returns
+ */
+export async function getPageInfoOfPostPage(pageId: string, from: string) {
+  const blockMap = await getPostBlocks(pageId, from);
+  if (!blockMap) {
+    return;
+  }
+
+  const postInfo = blockMap?.block?.[idToUuid(pageId)].value;
+
+  return {
+    id: pageId,
+    type: PagePropertiesType.Post,
+    category: '',
+    tags: [],
+    title: postInfo?.properties?.title?.[0],
+    status: PagePropertiesStatus.Published,
+    pageCover: getPageCover(postInfo),
+    date: {
+      type: 'date',
+      start_date: dayjs(postInfo.last_edited_time).format('yyyy-MM-dd'),
+    },
+    blockMap,
+    publishDate: dayjs(postInfo.created_time).valueOf(),
+    lastEditedDate: dayjs(postInfo.last_edited_time).valueOf(),
+    pageIcon: '',
+    pageCoverThumbnail: '',
+    content: [],
+    icon: '',
+    summary: '',
+    slug: '',
+  } as PageInfo;
+}
+
+function getPageCover(postInfo: Block) {
+  const pageCover = postInfo.format?.page_cover;
+  if (pageCover) {
+    if (pageCover.startsWith('/')) return BLOG.NOTION_HOST + pageCover;
+    if (pageCover.startsWith('http'))
+      return defaultMapImageUrl(pageCover, postInfo);
+  }
+}