@jeromefitz/notion 6.1.0 → 6.2.0-canary.1

package/src/queries/get-notion-slug-by-route/index.ts

@@ -0,0 +1,201 @@
+import { sortObject } from "@jeromefitz/utils";
+import { omit as _omit, size as _size } from "lodash-es";
+
+import { DATA_TYPES, PROPERTIES, QUERIES } from "../../constants/index";
+import { addTime, dataNormalized } from "../../utils/index";
+
+/**
+ * @note Determine if PARENT|CHILD should be returned:
+ *
+ * PARENT
+ * - /[parent-routeType]/[slug]
+ * - /podcasts/jer-and-ky-and-guest
+ *
+ * CHILD
+ * - /[parent-routeType]/[child-routeType]/[slug]
+ * - /podcasts/jer-and-ky-and-guest/am-i-dracula-greg-gillotti
+
+ *
+ */
+const getNotionSlugByRoute__getDataByParentRouteType = async ({
+  config,
+  getBlocksByIdChildren,
+  getDatabasesByIdQuery,
+  getQuery,
+  pathVariables,
+  routeType,
+  // slug,
+}) => {
+  const { NOTION } = config;
+  const { meta } = pathVariables;
+
+  const ROUTE_TYPE = routeType.toUpperCase();
+
+  const [parentSlug, slug] = meta;
+  const isChild = _size(meta) === 2;
+
+  const CHILD = NOTION[ROUTE_TYPE]?.hasChild?.toUpperCase();
+
+  const __info: any = await getDatabasesByIdQuery({
+    database_id: NOTION[isChild ? NOTION[CHILD].routeType.toUpperCase() : ROUTE_TYPE].database_id,
+    filter: {
+      and: [
+        {
+          ...QUERIES.slug,
+          rich_text: { equals: isChild ? slug : parentSlug },
+        },
+      ],
+    },
+  });
+
+  const _info = __info?.object === "list" && __info.results[0];
+  // @refactor(404)
+  if (!_info) {
+    return { content: {}, images: {}, info: {}, items: {} };
+  }
+  const info = _omit(_info, "properties");
+  info.properties = sortObject(
+    dataNormalized({ config, data: _info, pageId: info.id, pathVariables }),
+  );
+  const content = await getBlocksByIdChildren({ block_id: info.id });
+  let items = {};
+
+  /**
+   * @note if PARENT then get CHILDREN via `items`
+   */
+  if (!isChild) {
+    items = await getQuery({
+      config,
+      reqQuery: {
+        databaseType: NOTION[CHILD].routeType.toUpperCase(),
+        podcasts: info.id,
+      },
+    });
+  }
+
+  return { content, images: {}, info, items };
+};
+
+/**
+ * @note This is unique because the following are different:
+ *
+ * - /events/2020/05/01/jerome-and
+ * - /events/2020/05/08/jerome-and
+ * - /[routeType]/[yyyy/mm/dd]/[slug]
+ *
+ * We actually _do_ use the date for this.
+ *
+ */
+const getNotionSlugByRoute__getDataByListingDate = async ({
+  config,
+  getBlocksByIdChildren,
+  getDatabasesByIdQuery,
+  // getQuery,
+  pathVariables,
+  routeType,
+  slug,
+}) => {
+  const dateTimestamp = new Date().toISOString();
+
+  const { NOTION } = config;
+  const { meta } = pathVariables;
+
+  const [year, month, day] = meta;
+  /**
+   * @hack uh... nothing to see here, haha
+   */
+  const timestampQuery = new Date(
+    `${year ? year : dateTimestamp.slice(0, 4)}-${month ? month : "01"}-${day ? day : "01"}`,
+  );
+  const property =
+    NOTION[routeType.toUpperCase()]?.infoType?.notion ?? PROPERTIES.datePublished.notion;
+
+  const __info: any = await getDatabasesByIdQuery({
+    database_id: NOTION[routeType.toUpperCase()].database_id,
+    filter: {
+      and: [
+        {
+          date: {
+            on_or_after: addTime(timestampQuery, ""),
+          },
+          property,
+        },
+        {
+          date: {
+            before: addTime(timestampQuery, "day"),
+          },
+          property,
+        },
+        {
+          ...QUERIES.slug,
+          rich_text: { equals: slug },
+        },
+      ],
+    },
+  });
+
+  const _info = __info?.object === "list" && __info.results[0];
+  // @refactor(404)
+  if (!_info) {
+    return { content: {}, images: {}, info: {}, items: {} };
+  }
+
+  const info = _omit(_info, "properties");
+  info.properties = sortObject(
+    dataNormalized({ config, data: _info, pageId: info.id, pathVariables }),
+  );
+  const content = await getBlocksByIdChildren({ block_id: info.id });
+
+  return { content, images: {}, info, items: {} };
+};
+
+const getNotionSlugByRoute = async ({
+  config,
+  getBlocksByIdChildren,
+  getDatabasesByIdQuery,
+  getQuery,
+  pathVariables,
+  routeType,
+  slug,
+}) => {
+  const { NOTION, ROUTE_TYPES_BY_DATA_TYPES } = config;
+
+  /**
+   * @custom (notion) DATA_TYPES.SLUG_BY_ROUTE -- but customized:
+   * Determine if `routeType` is a parent|child
+   *
+   * // @todo(next-notion) move to `isChild`
+   *
+   */
+  if (NOTION[routeType?.toUpperCase()]?.hasChild) {
+    return await getNotionSlugByRoute__getDataByParentRouteType({
+      config,
+      getBlocksByIdChildren,
+      getDatabasesByIdQuery,
+      getQuery,
+      pathVariables,
+      routeType,
+      // slug,
+    });
+  }
+
+  /**
+   * @custom (notion) DATA_TYPES.LISTING_BY_DATE
+   *
+   */
+  if (ROUTE_TYPES_BY_DATA_TYPES[DATA_TYPES.LISTING_BY_DATE].includes(routeType.toUpperCase())) {
+    return await getNotionSlugByRoute__getDataByListingDate({
+      config,
+      getBlocksByIdChildren,
+      getDatabasesByIdQuery,
+      // getQuery,
+      pathVariables,
+      routeType,
+      slug,
+    });
+  }
+
+  return { content: {}, images: {}, info: {}, items: {} };
+};
+
+export default getNotionSlugByRoute;

package/src/queries/get-pages-by-id/index.ts

@@ -0,0 +1,12 @@
+import { avoidRateLimit, isUndefined } from "@jeromefitz/utils";
+
+// @todo(types)
+const getPagesById = async ({ getPagesRetrieve, page_id }) => {
+  if (isUndefined(page_id)) return [];
+  await avoidRateLimit(0);
+  return await getPagesRetrieve({
+    page_id,
+  });
+};
+
+export default getPagesById;

package/src/queries/get-path-variables/index.ts

@@ -0,0 +1,60 @@
+/**
+ * @refactor(lodash)
+ */
+import {
+  drop as _drop,
+  dropRight as _dropRight,
+  first as _first,
+  includes as _includes,
+  isInteger as _isInteger,
+  join as _join,
+  last as _last,
+  size as _size,
+} from "lodash-es";
+
+// import { DATA_TYPES } from '../../constants/index'
+import { getDataType } from "../../utils/index";
+
+const getPathVariables = ({ catchAll, config }) => {
+  const { NOTION, PAGES__HOMEPAGE, ROUTE_META, ROUTE_TYPES } = config;
+  const size: number = _size(catchAll);
+  const first: any = _first(catchAll);
+  const FIRST = first.toUpperCase();
+  const last: any = _last(catchAll);
+  // const LAST = last.toUpperCase()
+
+  const meta =
+    size > 1 && _includes(ROUTE_META, FIRST) ? _drop(catchAll) : _drop(_dropRight(catchAll));
+
+  const routeType =
+    first === last && !_includes(ROUTE_TYPES, FIRST) ? NOTION.PAGES.routeType : first;
+  const slug = first !== last && !_isInteger(parseInt(last)) ? last : first;
+
+  const isPage = routeType === NOTION.PAGES.routeType.toLowerCase();
+  const isIndex = slug === first;
+  const hasMeta = !!meta && _size(meta) !== 0;
+
+  const url = isPage && first === PAGES__HOMEPAGE ? "" : _join(catchAll, "/");
+
+  const pathVariables = {
+    hasMeta,
+    isIndex,
+    isPage,
+    meta,
+    routeType,
+    slug,
+    url,
+  };
+
+  // console.dir(`> pathVariables`)
+  // console.dir(pathVariables)
+
+  const dataType = getDataType(pathVariables);
+
+  return {
+    ...pathVariables,
+    dataType,
+  };
+};
+
+export default getPathVariables;

package/src/queries/get-query/index.ts

@@ -0,0 +1,140 @@
+import { avoidRateLimit, isObjectEmpty } from "@jeromefitz/utils";
+import { map as _map, omit as _omit, size as _size } from "lodash-es";
+
+import { PROPERTIES } from "../../constants/index";
+import type { SortItem } from "../../schema/index";
+import dataNormalizedResults from "../../utils/data-normalized-results/index";
+
+// const useCache = process.env.NEXT_PUBLIC__NOTION_USE_CACHE
+// const useCache = false
+
+const SORTS: SortItem[] = [
+  {
+    direction: "ascending",
+    property: PROPERTIES.slug.notion,
+  },
+];
+
+// @todo(complexity) 12
+// oxlint-disable-next-line complexity
+const getQuery = async ({ config, notionDatabasesQuery, reqQuery }) => {
+  const { NOTION } = config;
+  const { databaseType } = reqQuery;
+  const routeType = databaseType;
+  let hasError = false;
+
+  /**
+   * @setup
+   */
+  const DATABASE_TYPE = databaseType.toUpperCase();
+  const database_id = NOTION[DATABASE_TYPE].database_id;
+  if (!database_id) return [];
+
+  // @todo(types) any
+  let data: any = {},
+    items: any = {};
+  let filter: any, sorts: any;
+
+  /**
+   * @todo(notion) move this to the api so it can be re-used
+   *  not hidden in here all hacky
+   *
+   * @note(notion) right now only need this for episodes of podcasts
+   * _OR_ Related Databases (PODCASTS => EPISODES)
+   *
+   * This is not needed often and can/should probably be handled instead
+   *  with Relations & Rollups rather than this customization
+   */
+
+  if (databaseType === "EPISODES") {
+    sorts = SORTS;
+    const { podcasts } = reqQuery;
+
+    // @todo(types)
+    const filterTagEpisodesByPodcasts: any = [];
+    const podcastIds: any = [];
+
+    // oxlint-disable-next-line no-unused-expressions
+    !!podcasts && podcastIds.push(...podcasts?.split(","));
+    // oxlint-disable-next-line no-unused-expressions
+    _size(podcastIds) > 0 &&
+      _map(podcastIds, (id) =>
+        filterTagEpisodesByPodcasts.push({
+          property: PROPERTIES.relationEpisodes__Podcasts.notion,
+          relation: {
+            contains: id,
+          },
+        }),
+      );
+    filter = { or: [...filterTagEpisodesByPodcasts] };
+  } else {
+    // console.dir(`no filter`)
+    hasError = true;
+  }
+
+  // /**
+  //  * @cache pre
+  //  */
+  // if (useCache) {
+  //   const url = catchAll.join('/')
+  //   const cacheData = await getCache(url)
+  //   if (!!cacheData) {
+  //     data = cacheData
+  //   }
+  // }
+
+  if (!hasError && (!data || isObjectEmpty(data))) {
+    await avoidRateLimit(0);
+    // @todo(types) any
+    let contentData: Pick<any, number | string | symbol>;
+
+    // oxlint-disable-next-line no-extra-boolean-cast
+    if (!!filter) {
+      // @hack(notion)-do-not-return'
+      if (filter?.or.length === 0) {
+        filter = {
+          and: [
+            {
+              property: PROPERTIES.slug.notion,
+              rich_text: { equals: "@hack(notion)-do-not-return" },
+            },
+          ],
+        };
+      }
+      contentData = await notionDatabasesQuery({
+        database_id,
+        filter,
+        sorts,
+      });
+
+      data = contentData;
+      items = dataNormalizedResults({
+        config,
+        results: contentData.results,
+        routeType,
+      });
+      data = _omit(data, "results");
+      data.results = items;
+    } else {
+      // console.dir(`no filter`)
+      hasError = true;
+    }
+
+    // /**
+    //  * @cache post
+    //  */
+    // if (useCache && !!data) {
+    //   const url = catchAll.join('/')
+    //   // console.dir(url)
+    //   const isCacheExists = await getCache(url)
+    //   // console.dir(isCacheExists)
+    //   if (!isCacheExists || isCacheExists === undefined) {
+    //     setCache(data, url)
+    //   }
+    // }
+  }
+
+  return data;
+};
+
+export default getQuery;

package/src/queries/index.ts

@@ -0,0 +1,25 @@
+import getBlocksByIdChildren from "./get-blocks-by-id-children/index";
+import getDatabasesByIdQuery from "./get-databases-by-id-query/index";
+import getDeepFetchAllChildren from "./get-deep-fetch-all-children/index";
+import getInfoType from "./get-info-type/index";
+import getNotionListingByDate from "./get-notion-listing-by-date/index";
+import getNotionListing from "./get-notion-listing/index";
+import getNotionSlugByRoute from "./get-notion-slug-by-route/index";
+import getNotionSlug from "./get-notion-slug/index";
+import getPagesById from "./get-pages-by-id/index";
+import getPathVariables from "./get-path-variables/index";
+import getQuery from "./get-query/index";
+
+export {
+  getBlocksByIdChildren,
+  getDatabasesByIdQuery,
+  getDeepFetchAllChildren,
+  getInfoType,
+  getNotionListing,
+  getNotionListingByDate,
+  getNotionSlug,
+  getNotionSlugByRoute,
+  getPagesById,
+  getPathVariables,
+  getQuery,
+};