Merge pull request #49 from withmoons/manage-page-path-templates

feat: manage path template with url-template spec

packages/config/package.json

@@ -31,6 +31,7 @@
     "moons"
   ],
   "dependencies": {
+    "deepmerge": "4.3.1",
     "zod": "3.22.2"
   }
 }

packages/config/src/config.mts

@@ -1,3 +1,4 @@
+import deepmerge from 'deepmerge';
 import { existsSync, readFileSync } from 'fs';
 import { z } from 'zod';
 
@@ -6,20 +7,46 @@ import {
   type WebManifest,
 } from './webmanifest.config.mjs';
 import { join } from 'path';
+import { pageDocumentTypes } from './consts.mjs';
 
 const localesSchema = z.object({
   default: z.string(),
   available: z.array(z.string()),
 });
 
+const pageSchema = z.object({
+  path: z
+    .array(
+      z.object({
+        locale: z.string(),
+        path: z.string(),
+      })
+    )
+    .or(z.string()),
+});
+
 const moonsConfigFileSchema = z.object({
   locales: localesSchema.optional(),
   template: z.string(),
+  pages: z
+    .object(
+      Object.fromEntries(
+        Object.values(pageDocumentTypes).map((key) => [
+          key,
+          pageSchema.or(z.literal(false)).optional(),
+        ])
+      )
+    )
+    .optional(),
 });
 
 const defaultConfigFileName = 'moons.config.json';
 
-export type MoonsConfig = z.infer<typeof moonsConfigFileSchema> & {
+type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
+export type MoonsConfig = WithRequired<
+  z.infer<typeof moonsConfigFileSchema>,
+  'pages'
+> & {
   name?: string;
   content: {
     root: string;
@@ -28,6 +55,24 @@ export type MoonsConfig = z.infer<typeof moonsConfigFileSchema> & {
   webManifest: WebManifest;
 };
 
+const defaultPages: MoonsConfig['pages'] = {
+  articles: {
+    path: '/{+isPartOf}/{/identifier}',
+  },
+
+  pages: {
+    path: '/{+isPartOf}{/identifier}',
+  },
+
+  people: {
+    path: '/authors/{/identifier}',
+  },
+
+  organizations: {
+    path: '/organizations/{/identifier}',
+  },
+};
+
 let _config: MoonsConfig;
 
 const readConfigFile = (path: string): MoonsConfig => {
@@ -39,14 +84,15 @@ const readConfigFile = (path: string): MoonsConfig => {
   const configFileContent = readFileSync(configPath, 'utf8');
   const configFile = moonsConfigFileSchema.parse(JSON.parse(configFileContent));
 
-  const config: MoonsConfig = {
-    ...configFile,
+  const defaultConfig = {
+    pages: defaultPages,
     content: {
       root: path,
       generated: join(path, '.contentlayer/generated/index.mjs'),
     },
     webManifest: readWebManifestFromPath(path),
   };
+  const config: MoonsConfig = deepmerge(defaultConfig, configFile);
 
   return config;
 };

packages/config/src/consts.mts

@@ -0,0 +1,14 @@
+export enum pageDocumentTypes {
+  Article = 'articles',
+  Organization = 'organizations',
+  Page = 'pages',
+  Person = 'people',
+}
+export enum documentTypes {
+  Article = pageDocumentTypes.Article,
+  Organization = pageDocumentTypes.Organization,
+  Page = pageDocumentTypes.Page,
+  Person = pageDocumentTypes.Person,
+  WebPageElement = 'webPageElements',
+  Website = 'websites',
+}

packages/config/src/index.mts

@@ -1,2 +1,3 @@
 export * from './config.mjs';
+export * from './consts.mjs';
 export * from './webmanifest.config.mjs';

packages/moons/package.json

@@ -31,6 +31,7 @@
     "moons"
   ],
   "dependencies": {
+    "@std-uritemplate/std-uritemplate": "0.0.40",
     "@withmoons/config": "*",
     "esbuild": "0.19.2",
     "mdx-bundler": "9.2.1",

packages/moons/src/core/content/compute.mts

@@ -18,9 +18,7 @@ import {
 } from './urls.mjs';
 import {
   documentByIdentifierAndLanguageSelector,
-  documentsByAuthorSelector,
   isInLanguage,
-  usedLanguagesInDocumentsSelector,
 } from './selectors.mjs';
 import type {
   Content,
@@ -33,22 +31,19 @@ import type {
 export type ComputeDTO<T> = {
   documents: T[];
   websites: ContentlayerWebsite[];
-  persons: ContentlayerPerson[];
+  people: ContentlayerPerson[];
 };
 
 function createPage<T>(
   identifier: string,
-  path: string,
   document: Partial<ContentlayerWebPageDocument>
 ) {
   return {
     _id: identifier,
     identifier,
-    path,
     slug: identifier,
     description: '',
     type: 'Page',
-    collection: 'pages',
     name: identifier,
     ...document,
     body: document.body?.raw
@@ -63,12 +58,10 @@ function createPage<T>(
 
 const createListingPage = (
   identifier: string,
-  path: string,
   document: Partial<ContentlayerWebPageDocument> = {}
 ) =>
   createPage<ContentlayerDocumentWithRender<ContentlayerWebPageDocument>>(
     identifier,
-    path,
     {
       listingPage: true,
       ...document,
@@ -112,9 +105,7 @@ const computeRemainingListingPages = async (
           (_a) => _a.identifier === isPartOf && isInLanguage(_a, inLanguage)
         ) === false
       ) {
-        acc = acc.concat(
-          createListingPage(isPartOf, `/${isPartOf}`, templateDocument)
-        );
+        acc = acc.concat(createListingPage(isPartOf, templateDocument));
       }
 
       // Create all keywords pages not existing yet
@@ -124,9 +115,7 @@ const computeRemainingListingPages = async (
             (_a) => _a.identifier === 'tags' && isInLanguage(_a, inLanguage)
           ) === false
         ) {
-          acc = acc.concat(
-            createListingPage('tags', '/tags', templateDocument)
-          );
+          acc = acc.concat(createListingPage('tags', templateDocument));
         }
 
         acc = acc.concat(
@@ -138,7 +127,7 @@ const computeRemainingListingPages = async (
                 ) === false
             )
             .map((_k) =>
-              createListingPage(_k, `/${_k}`, {
+              createListingPage(_k, {
                 ...templateDocument,
                 isPartOf: 'tags',
               })
@@ -151,44 +140,8 @@ const computeRemainingListingPages = async (
     documents
   );
 
-const computePersonPages =
-  (persons: ContentlayerPerson[]) =>
-  async (documents: ContentlayerWebPageDocumentWithRender[]) => {
-    const selectUsedLanguages = usedLanguagesInDocumentsSelector();
-    const selectDocumentByAuthor = documentsByAuthorSelector(documents);
-
-    if (Array.isArray(persons) && persons.length > 0) {
-      const usedLanguages = selectUsedLanguages(documents);
-      documents = documents.concat(
-        ...usedLanguages.map((language) =>
-          createListingPage('author', '/author', { inLanguage: language })
-        )
-      );
-    }
-
-    return persons.reduce((acc, person) => {
-      if (!person.body) {
-        return acc;
-      }
-
-      const usedLanguages = selectUsedLanguages(
-        selectDocumentByAuthor(person.identifier)
-      );
-      return acc.concat(
-        ...usedLanguages.map<ContentlayerWebPageDocumentWithRender>(
-          (language) =>
-            createPage(person.identifier, person.identifier, {
-              body: person.body,
-              isPartOf: 'author',
-              inLanguage: language,
-            })
-        )
-      );
-    }, documents);
-  };
-
 const computeMissingFields =
-  (persons: ContentlayerPerson[]) =>
+  (people: ContentlayerPerson[]) =>
   async (
     documents: Array<
       ContentlayerDocumentWithURL & ContentlayerWebPageDocumentWithRender
@@ -197,7 +150,7 @@ const computeMissingFields =
     const buildBreadcrumb = breadcrumbBuilder(documents);
     const buildAlternates = alternatesHeaderBuilder(documents);
     const selectPersonByIdentifierAndLanguage =
-      documentByIdentifierAndLanguageSelector(persons);
+      documentByIdentifierAndLanguageSelector(people);
 
     const getAuthor = (
       identifier?: string,
@@ -206,8 +159,8 @@ const computeMissingFields =
       let author;
       if (identifier) {
         author = selectPersonByIdentifierAndLanguage(identifier, inLanguage);
-      } else if (persons.length === 1) {
-        author = persons[0];
+      } else if (people.length === 1) {
+        author = people[0];
       }
 
       return (
@@ -252,12 +205,11 @@ const computeMissingFields =
 
 export const computeDocuments = async ({
   documents,
-  persons,
+  people,
   websites,
 }: ComputeDTO<ContentlayerWebPageDocument>): Promise<Content[]> =>
   Promise.resolve(documents)
     .then(hydratePagesWithRender)
-    .then(computePersonPages(persons))
     .then(computeRemainingListingPages)
     .then(computeDocumentsUrl(websites))
-    .then(computeMissingFields(persons));
+    .then(computeMissingFields(people));

packages/moons/src/core/content/consts.mts

@@ -1,9 +1,2 @@
 export const homeIdentifier = 'index';
 export const pageDepthLimit = 10;
-
-export enum collectionName {
-  article = 'articles',
-  page = 'pages',
-  person = 'persons',
-  organization = 'organizations',
-}

packages/moons/src/core/content/index.mts

@@ -1,3 +1,2 @@
-export { collectionName } from './consts.mjs';
 export * from './repository.mjs';
 export * from './types/index.mjs';

packages/moons/src/core/content/metadata/breadcrumb.mts

@@ -34,7 +34,9 @@ export const breadcrumbBuilder =
         inLanguage
       );
       if (!page) {
-        throw new Error('No page found during breadcrumb computation');
+        throw new Error(
+          `No page ${documentIdentifier} in ${inLanguage} found during breadcrumb computation`
+        );
       }
 
       itemList = itemList.concat({

packages/moons/src/core/content/metadata/ogp/og.mts

@@ -1,4 +1,3 @@
-import { collectionName } from '../../consts.mjs';
 import type { Content, MetadataHeaders } from '../../types/index.mjs';
 
 import { getArticle } from './article.mjs';
@@ -7,7 +6,7 @@ import { getWebsite } from './website.mjs';
 export const getOpenGraphObjects = (
   document: Content
 ): MetadataHeaders['openGraph'] => {
-  if (document.collection === collectionName.article) {
+  if (document.type === 'Article') {
     return getArticle(document);
   }
 

packages/moons/src/core/content/metadata/schemas/structured-data.mts

@@ -1,14 +1,13 @@
 import type { Thing, WithContext } from 'schema-dts';
 
-import { collectionName } from '../../consts.mjs';
 import type { Content } from '../../types/index.mjs';
 import { getArticle } from './article.mjs';
 import { getBreadcrumb } from './breadcrumb.mjs';
 
 export const getStructuredDataSchemas = (document: Content) => {
   let schemas: WithContext<Thing>[] = [getBreadcrumb(document)];
 
-  if (document.collection === collectionName.article) {
+  if (document.type === 'Article') {
     schemas = schemas.concat(getArticle(document));
   }
 

packages/moons/src/core/content/repository.mts

@@ -65,8 +65,9 @@ const getWebPageDocuments = async (): Promise<Content[]> => {
     websites: await getWebsites(),
     documents: new Array<ContentlayerWebPageDocument>()
       .concat(generated.allPages)
-      .concat(generated.allArticles),
-    persons: await getPersons(),
+      .concat(generated.allArticles)
+      .concat(generated.allPeople),
+    people: generated.allPeople,
   });
 
   return _documents;
@@ -102,10 +103,6 @@ export const getPageBySlug = async (
   filters?: RepositoryFilters
 ) => (await getPages(filters)).find((doc) => doc.slug === slug);
 
-export const getPersons = async () => (await getGenerated()).allPeople;
-export const getPersonByIdentifier = async (identifier: string) =>
-  documentByIdentifierSelector(await getPersons())(identifier);
-
 export const getOrganizations = async () =>
   (await getGenerated()).allOrganizations;
 export const getOrganizationByIdentifier = async (identifier: string) =>

packages/moons/src/core/content/types/_schemas.mts

@@ -1,5 +1,5 @@
+import { documentTypes } from '@withmoons/config';
 import { z } from 'zod';
-import { collectionName } from '../consts.mjs';
 
 const metadataHeaders = z
   .object({
@@ -38,9 +38,7 @@ const metadataHeaders = z
 
 const moonsSchema = z
   .object({
-    collection: z
-      .enum(Object.values(collectionName) as [string, ...string[]])
-      .or(z.string()),
+    type: z.enum(Object.keys(documentTypes) as [keyof typeof documentTypes]),
     tags: z.array(z.string()).optional(),
     listingPage: z.boolean().default(false),
     path: z.string(),