sitero 0.5.0 → 0.7.0

package/dist/src/core/infrastructure/prisma/post/lifecycle.js

@@ -0,0 +1,108 @@
+import { POST_ERROR_CODES, OperationError } from 'sitero-server';
+
+async function lockPostWrites(tx) {
+  await tx.$queryRaw`SELECT pg_advisory_xact_lock(1936286821, 1)::text`;
+}
+function fail(code, ids = []) {
+  throw new OperationError({ code, details: { postIds: ids } });
+}
+async function requirePost(tx, id, deleted = false) {
+  const post = await tx.post.findUnique({ where: { id } });
+  if (!post) fail(POST_ERROR_CODES.NOT_FOUND);
+  if (!!post.deletedAt !== deleted) fail(POST_ERROR_CODES.INVALID_STATE);
+  return post;
+}
+async function assertNoPostReferences(tx, id) {
+  const references = await tx.post.findMany({
+    where: {
+      id: { not: id },
+      OR: [
+        { parents: { some: { id } } },
+        { tags: { some: { id } } },
+        { relatedPosts: { some: { id } } }
+      ]
+    },
+    select: { id: true }
+  });
+  if (references.length)
+    fail(
+      POST_ERROR_CODES.IN_USE,
+      references.map(({ id: id2 }) => id2)
+    );
+}
+async function assertPublishedAncestors(tx, ids) {
+  const visited = /* @__PURE__ */ new Set();
+  let pending = ids;
+  while (pending.length) {
+    const batch = [...new Set(pending)].filter((id) => !visited.has(id));
+    if (!batch.length) break;
+    batch.forEach((id) => visited.add(id));
+    const parents = await tx.post.findMany({
+      where: { id: { in: batch } },
+      include: { parents: { select: { id: true } } }
+    });
+    const unavailable = batch.filter(
+      (id) => !parents.some((p) => p.id === id && p.isActive && !p.deletedAt)
+    );
+    if (unavailable.length)
+      fail(POST_ERROR_CODES.PARENT_UNPUBLISHED, unavailable);
+    pending = parents.flatMap((p) => p.parents.map(({ id }) => id));
+  }
+}
+async function assertNoPublishedDescendants(tx, id) {
+  const visited = /* @__PURE__ */ new Set([id]);
+  let pending = [id];
+  while (pending.length) {
+    const children = await tx.post.findMany({
+      where: { parents: { some: { id: { in: pending } } } },
+      select: { id: true, isActive: true, deletedAt: true }
+    });
+    const published = children.filter(
+      (child) => child.isActive && !child.deletedAt
+    );
+    if (published.length)
+      fail(
+        POST_ERROR_CODES.HAS_PUBLISHED_CHILDREN,
+        published.map(({ id: id2 }) => id2)
+      );
+    pending = children.map(({ id: id2 }) => id2).filter((id2) => !visited.has(id2));
+    pending.forEach((id2) => visited.add(id2));
+  }
+}
+async function assertPostWrite(tx, input, id, previous) {
+  const type = previous?.type ?? input.type;
+  const topicKey = previous ? previous.topicKey : input.topicKey;
+  const slug = input.slug?.trim() || id;
+  const conflict = await tx.post.findFirst({
+    where: { type, topicKey, slug, id: { not: id } },
+    select: { id: true }
+  });
+  if (conflict) fail(POST_ERROR_CODES.SLUG_CONFLICT, [conflict.id]);
+  const ids = [
+    ...new Set(
+      [...input.parents, ...input.tags, ...input.relatedPosts].map(
+        ({ id: id2 }) => id2
+      )
+    )
+  ];
+  if (ids.length) {
+    const records = await tx.post.findMany({
+      where: { id: { in: ids }, deletedAt: null },
+      select: { id: true }
+    });
+    const unavailable = ids.filter(
+      (id2) => !records.some((record) => record.id === id2)
+    );
+    if (unavailable.length)
+      fail(POST_ERROR_CODES.REFERENCE_UNAVAILABLE, unavailable);
+  }
+  if (input.isActive)
+    await assertPublishedAncestors(
+      tx,
+      input.parents.map(({ id: id2 }) => id2)
+    );
+  if (!input.isActive && (type === "CATEGORY" || type === "SUBCATEGORY"))
+    await assertNoPublishedDescendants(tx, id);
+}
+
+export { assertNoPostReferences, assertPostWrite, lockPostWrites, requirePost };

package/dist/src/core/infrastructure/prisma/post/mappers.js

@@ -18,24 +18,27 @@ function postReferenceToDomain(post) {
     translations: post.translations.map(translationToDomain)
   };
 }
-function postListCardToDomain(post) {
+function postReferenceWithCoverToDomain(post) {
   return {
     ...postReferenceToDomain(post),
-    topic: post.topic ? postReferenceToDomain(post.topic) : null,
     coverImage: post.coverImage ? fileToCard(post.coverImage) : null
   };
 }
+function postListCardToDomain(post) {
+  return {
+    ...postReferenceWithCoverToDomain(post),
+    parents: post.parents.map(postReferenceWithCoverToDomain)
+  };
+}
 function postDetailToDomain(post) {
   const author = post.author ? adminListCardToDomain(post.author) : null;
   return {
     ...postListCardToDomain(post),
     author,
-    postsInTopic: post.postsInTopic.map(postReferenceToDomain),
-    parents: post.parents.map(postReferenceToDomain),
     children: post.children.map(postReferenceToDomain),
     tags: post.tags.map(postReferenceToDomain),
     taggedPosts: post.taggedPosts.map(postReferenceToDomain),
-    relatedPosts: post.relatedPosts.map(postReferenceToDomain),
+    relatedPosts: post.relatedPosts.map(postListCardToDomain),
     referencingPosts: post.referencingPosts.map(postReferenceToDomain),
     contentImages: post.contentImages.map(fileToCard),
     files1: post.files1.map(fileToCard),
@@ -66,4 +69,4 @@ function postRelationsToDomain(post) {
   };
 }
 
-export { postDetailToDomain, postListCardToDomain, postReferenceToDomain, postRelationsToDomain };
+export { postDetailToDomain, postListCardToDomain, postReferenceToDomain, postReferenceWithCoverToDomain, postRelationsToDomain };

package/dist/src/core/infrastructure/prisma/post/post-prisma-ports.js

@@ -1,10 +1,13 @@
+import { OperationError, POST_ERROR_CODES } from 'sitero-server';
 import { ulid } from 'ulid';
 import { withActiveFileReferences } from '../helpers/active-file-references.js';
 import { connectOrDisconnectOne, setMany, connectOne, connectMany } from '../helpers/relation-writes.js';
 import { createSearchWhere } from '../helpers/search-where.js';
 import { postToDomain } from './base-mappers.js';
-import { POST_RELATIONS_INCLUDE, POST_DETAIL_INCLUDE, POST_LIST_CARD_INCLUDE, POST_REFERENCE_INCLUDE } from './include.js';
+import { POST_RELATIONS_INCLUDE, POST_REFERENCE_INCLUDE } from './include.js';
+import { lockPostWrites, requirePost, assertNoPostReferences, assertPostWrite } from './lifecycle.js';
 import { postRelationsToDomain, postListCardToDomain, postDetailToDomain, postReferenceToDomain } from './mappers.js';
+import { postReadWhere, postDetailInclude, postListInclude } from './read-scope.js';
 
 const SEARCH_TEXT_FIELDS = [
   "text1",
@@ -55,6 +58,7 @@ function createPostPrismaPorts(prisma) {
     // ------------------------------------------------------------
     postCommandPort: {
       async create(input) {
+        const id = ulid();
         return withActiveFileReferences(
           prisma,
           [
@@ -68,10 +72,8 @@ function createPostPrismaPorts(prisma) {
             input.file4
           ],
           async (transaction) => {
-            const id = ulid();
             const {
               author,
-              topic,
               parents,
               tags,
               relatedPosts,
@@ -88,7 +90,6 @@ function createPostPrismaPorts(prisma) {
               ...scalars
             } = input;
             const authorWrite = connectOne(author);
-            const topicWrite = connectOne(topic);
             const coverImageWrite = connectOne(coverImage);
             const file1Write = connectOne(file1);
             const file2Write = connectOne(file2);
@@ -100,7 +101,6 @@ function createPostPrismaPorts(prisma) {
                 id,
                 slug: slug?.trim() || id,
                 ...authorWrite ? { author: authorWrite } : {},
-                ...topicWrite ? { topic: topicWrite } : {},
                 parents: connectMany(parents),
                 tags: connectMany(tags),
                 relatedPosts: connectMany(relatedPosts),
@@ -116,6 +116,10 @@ function createPostPrismaPorts(prisma) {
               }
             });
             return postToDomain(post);
+          },
+          async (tx) => {
+            await lockPostWrites(tx);
+            await assertPostWrite(tx, input, id);
           }
         );
       },
@@ -136,7 +140,6 @@ function createPostPrismaPorts(prisma) {
             const {
               id,
               author,
-              topic,
               parents,
               tags,
               relatedPosts,
@@ -153,12 +156,11 @@ function createPostPrismaPorts(prisma) {
               ...scalars
             } = input;
             const post = await transaction.post.update({
-              where: { id },
+              where: { id, deletedAt: null },
               data: {
                 ...scalars,
                 slug: slug?.trim() || id,
                 author: connectOrDisconnectOne(author),
-                topic: connectOrDisconnectOne(topic),
                 parents: setMany(parents),
                 tags: setMany(tags),
                 relatedPosts: setMany(relatedPosts),
@@ -182,13 +184,54 @@ function createPostPrismaPorts(prisma) {
               }
             });
             return postToDomain(post);
+          },
+          async (tx) => {
+            await lockPostWrites(tx);
+            const previous = await requirePost(tx, input.id);
+            await assertPostWrite(tx, input, input.id, previous);
           }
         );
       },
       async delete({ id }) {
-        return postToDomain(
-          await prisma.post.delete({ where: { id, isLocked: false } })
-        );
+        return prisma.$transaction(async (tx) => {
+          await lockPostWrites(tx);
+          const post = await requirePost(tx, id);
+          if (post.isLocked)
+            throw new OperationError({ code: POST_ERROR_CODES.DELETE_LOCKED });
+          await assertNoPostReferences(tx, id);
+          return postToDomain(
+            await tx.post.update({
+              where: { id, deletedAt: null, isLocked: false },
+              data: { deletedAt: /* @__PURE__ */ new Date(), isActive: false }
+            })
+          );
+        });
+      },
+      async restore({ id }) {
+        return prisma.$transaction(async (tx) => {
+          await lockPostWrites(tx);
+          await requirePost(tx, id, true);
+          return postToDomain(
+            await tx.post.update({
+              where: { id, deletedAt: { not: null } },
+              data: { deletedAt: null, isActive: false }
+            })
+          );
+        });
+      },
+      async purge({ id }) {
+        return prisma.$transaction(async (tx) => {
+          await lockPostWrites(tx);
+          const post = await requirePost(tx, id, true);
+          if (post.isLocked)
+            throw new OperationError({ code: POST_ERROR_CODES.DELETE_LOCKED });
+          await assertNoPostReferences(tx, id);
+          return postToDomain(
+            await tx.post.delete({
+              where: { id, deletedAt: { not: null }, isLocked: false }
+            })
+          );
+        });
       }
     },
     // ------------------------------------------------------------
@@ -198,8 +241,9 @@ function createPostPrismaPorts(prisma) {
       async findMany(input) {
         const posts = await prisma.post.findMany({
           where: {
+            ...postReadWhere(input),
             ...input?.type ? { type: input.type } : {},
-            ...input?.topicId === void 0 ? {} : { topicId: input.topicId },
+            ...input?.topicKey === void 0 ? {} : { topicKey: input.topicKey },
             ...input?.postIds ? { id: { in: input.postIds } } : {}
           },
           orderBy,
@@ -227,10 +271,8 @@ function createPostPrismaPorts(prisma) {
         const where = {
           ...customStateFilters,
           ...input.type ? { type: input.type } : {},
-          ...input.topicId === void 0 ? {} : { topicId: input.topicId },
-          ...input.topicSlug ? { topic: { slug: input.topicSlug } } : {},
-          ...input.parentId ? { parents: { some: { id: input.parentId } } } : {},
-          ...input.parentSlug ? { parents: { some: { slug: input.parentSlug } } } : {},
+          ...input.topicKey === void 0 ? {} : { topicKey: input.topicKey },
+          ...input.topicSlug ? { AND: [{ topicKey: input.topicSlug }] } : {},
           ...input.authorId ? { authorId: input.authorId } : {},
           ...input.postIds || input.excludeIds ? {
             id: {
@@ -253,16 +295,24 @@ function createPostPrismaPorts(prisma) {
           })
         };
         const pagination = input.page && input.pageSize ? { skip: (input.page - 1) * input.pageSize, take: input.pageSize } : {};
+        const scopedWhere = {
+          AND: [
+            where,
+            postReadWhere(input),
+            ...input.parentId ? [{ parents: { some: { id: input.parentId } } }] : [],
+            ...input.parentSlug ? [{ parents: { some: { slug: input.parentSlug } } }] : []
+          ]
+        };
         const findManyInput = {
-          where,
+          where: scopedWhere,
           orderBy,
-          include: POST_LIST_CARD_INCLUDE,
+          include: postListInclude(input),
           ...pagination
         };
         const result = await prisma.$transaction(async (transaction) => {
           const [items, total] = await Promise.all([
             transaction.post.findMany(findManyInput),
-            transaction.post.count({ where })
+            transaction.post.count({ where: scopedWhere })
           ]);
           return { items, total };
         });
@@ -274,17 +324,19 @@ function createPostPrismaPorts(prisma) {
       async findDetail(input) {
         const lookup = "id" in input ? { id: input.id } : { type: input.type, slug: input.slug };
         const scope = {
+          AND: [postReadWhere(input)],
           ...input.isActive === void 0 ? {} : { isActive: input.isActive },
-          ...input.topicSlug ? { topic: { slug: input.topicSlug } } : {}
+          ...input.topicSlug ? { topicKey: input.topicSlug } : {}
         };
         const post = await prisma.post.findFirst({
           where: { ...scope, ...lookup },
-          include: POST_DETAIL_INCLUDE
+          include: postDetailInclude(input)
         });
         if (!post) return { post: null, previous: null, next: null };
         const adjacentWhere = {
           ...scope,
-          ..."id" in input ? {} : { type: input.type }
+          type: post.type,
+          topicKey: post.topicKey
         };
         const [previous, next] = await Promise.all([
           prisma.post.findFirst({
@@ -292,14 +344,14 @@ function createPostPrismaPorts(prisma) {
             orderBy: orderBy.map(reverseOrderBy),
             cursor: { id: post.id },
             skip: 1,
-            include: POST_LIST_CARD_INCLUDE
+            include: postListInclude(input)
           }),
           prisma.post.findFirst({
             where: adjacentWhere,
             orderBy,
             cursor: { id: post.id },
             skip: 1,
-            include: POST_LIST_CARD_INCLUDE
+            include: postListInclude(input)
           })
         ]);
         return {

package/dist/src/core/infrastructure/prisma/post/read-scope.js

@@ -0,0 +1,45 @@
+import { POST_DETAIL_INCLUDE, POST_REFERENCE_INCLUDE, POST_LIST_CARD_INCLUDE, POST_REFERENCE_WITH_COVER_INCLUDE } from './include.js';
+
+const active = { isActive: true, deletedAt: null };
+const publishedParent = {
+  ...active,
+  parents: { every: active }
+};
+const PUBLIC_POST_WHERE = {
+  ...active,
+  parents: { every: publishedParent }
+};
+function postReadWhere(scope) {
+  const deletion = scope?.deletion === "all" ? {} : {
+    deletedAt: scope?.deletion === "deleted" ? { not: null } : null
+  };
+  return scope?.visibility === "public" ? { AND: [PUBLIC_POST_WHERE, deletion] } : deletion;
+}
+function postListInclude(scope) {
+  if (scope?.visibility !== "public") return POST_LIST_CARD_INCLUDE;
+  return {
+    ...POST_LIST_CARD_INCLUDE,
+    parents: {
+      where: PUBLIC_POST_WHERE,
+      include: POST_REFERENCE_WITH_COVER_INCLUDE
+    }
+  };
+}
+function postDetailInclude(scope) {
+  if (scope?.visibility !== "public") return POST_DETAIL_INCLUDE;
+  const reference = {
+    where: PUBLIC_POST_WHERE,
+    include: POST_REFERENCE_INCLUDE
+  };
+  return {
+    ...POST_DETAIL_INCLUDE,
+    ...postListInclude(scope),
+    children: reference,
+    tags: reference,
+    taggedPosts: reference,
+    relatedPosts: { where: PUBLIC_POST_WHERE, include: postListInclude(scope) },
+    referencingPosts: reference
+  };
+}
+
+export { PUBLIC_POST_WHERE, postDetailInclude, postListInclude, postReadWhere };

package/dist/src/core/infrastructure/prisma/seo-metadata/mappers.js

@@ -6,8 +6,13 @@ function seoMetadataToWrite(data) {
   };
 }
 function seoMetadataToDomain(seoMetadata) {
+  const { postId, pageId, ...data } = seoMetadata;
+  if (postId != null === (pageId != null))
+    throw new Error("Invalid SEO metadata owner");
+  const owner = postId != null ? { postId, pageId: null } : { pageId, postId: null };
   return {
-    ...seoMetadata,
+    ...data,
+    ...owner,
     alternate: seoMetadata.alternate,
     jsonLd: seoMetadata.jsonLd
   };

package/dist/src/core/infrastructure/prisma/seo-metadata/seo-metadata-prisma-ports.js

@@ -1,3 +1,4 @@
+import { lockPostWrites, requirePost } from '../post/lifecycle.js';
 import { seoMetadataToWrite, seoMetadataToDomain } from './mappers.js';
 
 function createSeoMetadataPrismaPorts(prisma) {
@@ -6,17 +7,37 @@ function createSeoMetadataPrismaPorts(prisma) {
     // Command
     // ------------------------------------------------------------
     seoMetadataCommandPort: {
-      async upsert({ postId, translations }) {
-        const seoMetadatas = await prisma.$transaction(
-          translations.map((translation) => {
-            const data = seoMetadataToWrite(translation);
-            return prisma.seoMetadata.upsert({
-              where: { postId_locale: { postId, locale: translation.locale } },
-              update: data,
-              create: { postId, ...data }
-            });
-          })
-        );
+      async upsert(input) {
+        const { translations } = input;
+        const seoMetadatas = await prisma.$transaction(async (tx) => {
+          if (input.postId !== void 0) {
+            await lockPostWrites(tx);
+            await requirePost(tx, input.postId);
+          }
+          return Promise.all(
+            translations.map((translation) => {
+              const data = seoMetadataToWrite(translation);
+              return tx.seoMetadata.upsert({
+                where: input.postId !== void 0 ? {
+                  postId_locale: {
+                    postId: input.postId,
+                    locale: translation.locale
+                  }
+                } : {
+                  pageId_locale: {
+                    pageId: input.pageId,
+                    locale: translation.locale
+                  }
+                },
+                update: data,
+                create: {
+                  ...data,
+                  ...input.postId !== void 0 ? { postId: input.postId, pageId: null } : { pageId: input.pageId, postId: null }
+                }
+              });
+            })
+          );
+        });
         return seoMetadatas.map(seoMetadataToDomain);
       }
     }

package/dist/src/core/seeders/page/seeder.js

@@ -1,39 +1,19 @@
-import { POST_TYPES } from 'sitero-domain';
-
 function pageSeeder({
   prisma,
-  pages: staticPages,
+  pages,
   locales
 }) {
-  async function checkExistence(slug) {
-    const page = await prisma.post.findFirst({
-      where: { type: POST_TYPES.PAGE, slug },
-      select: { id: true }
-    });
-    return page ? true : false;
-  }
   async function seed() {
-    const pages = Object.entries(staticPages).map(([slug, data]) => ({
-      slug,
-      ...data
-    }));
-    for (const [i, item] of pages.entries()) {
-      const exists = await checkExistence(item.slug);
-      if (exists) continue;
-      await prisma.post.create({
-        data: {
-          type: POST_TYPES.PAGE,
-          // states
-          isActive: true,
-          isSlugActive: true,
-          slug: item.slug,
-          isIndexActive: true,
-          index: i + 1,
-          // translation
+    for (const [key, page] of Object.entries(pages)) {
+      await prisma.page.upsert({
+        where: { key },
+        update: {},
+        create: {
+          key,
           translations: {
-            create: locales.map((locale) => ({
+            create: [...new Set(locales)].map((locale) => ({
               locale,
-              title: item.title[locale]
+              title: page.title[locale] ?? null
             }))
           }
         }

package/dist/src/core/seeders/seed.js

@@ -1,20 +1,17 @@
 import { adminSeeder } from './admin/seeder.js';
 import { configSeeder } from './config/seeder.js';
 import { pageSeeder } from './page/seeder.js';
-import { topicSeeder } from './topic/seeder.js';
 
 async function seed({
   prisma,
   webLocales: locales,
   admins,
   pages,
-  topics,
   configs
 }) {
   const siteroPrisma = prisma;
   await adminSeeder({ prisma: siteroPrisma, locales, admins }).seed();
   await pageSeeder({ prisma: siteroPrisma, locales, pages }).seed();
-  await topicSeeder({ prisma: siteroPrisma, locales, topics }).seed();
   await configSeeder({ prisma: siteroPrisma, locales, configs }).seed();
 }
 

package/dist/src/core/sitero-server/create-sitero-server.js

@@ -10,6 +10,8 @@ import { createFilePrismaPorts } from '../infrastructure/prisma/file/file-prisma
 import { createInquiryPrismaPorts } from '../infrastructure/prisma/inquiry/inquiry-prisma-ports.js';
 import { createPostPrismaPorts } from '../infrastructure/prisma/post/post-prisma-ports.js';
 import { createSeoMetadataPrismaPorts } from '../infrastructure/prisma/seo-metadata/seo-metadata-prisma-ports.js';
+import { createPagePrismaPorts } from '../infrastructure/prisma/page/page-prisma-ports.js';
+import '../infrastructure/prisma/page/include.js';
 import { createRedisRateLimiterPort } from '../infrastructure/rate-limiter/create-redis-rate-limiter-port.js';
 import { getRedisClient } from '../infrastructure/redis/create-redis-client.js';
 import { createEmailComposition } from './email.js';
@@ -51,12 +53,19 @@ function createSiteroServer(input) {
   const prisma = input.prisma;
   const adminPrismaPorts = createAdminPrismaPorts(prisma);
   const adminRefreshTokenPrismaPorts = createAdminRefreshTokenPrismaPorts(prisma);
+  const pagePrismaPorts = createPagePrismaPorts(prisma);
   const configPrismaPorts = createConfigPrismaPorts(prisma);
   const filePrismaPorts = createFilePrismaPorts(prisma);
   const inquiryPrismaPorts = createInquiryPrismaPorts(prisma);
   const postPrismaPorts = createPostPrismaPorts(prisma);
   const seoMetadataPrismaPorts = createSeoMetadataPrismaPorts(prisma);
   return createSiteroServer$1({
+    topics: Object.fromEntries(
+      Object.entries(input.topics).map(([key, { roles }]) => [
+        key,
+        { roles: [...roles] }
+      ])
+    ),
     authentication: {
       admin: {
         refreshTokenTtlSeconds: input.authentication?.refreshTokenTtlSeconds
@@ -79,6 +88,7 @@ function createSiteroServer(input) {
         }
       },
       resources: {
+        page: pagePrismaPorts,
         admin: {
           adminCommandPort: adminPrismaPorts.adminCommandPort,
           adminInquiryNotificationRecipientQueryPort: adminPrismaPorts.adminInquiryNotificationRecipientQueryPort,

package/dist/src/web/server/create-web-server.js

@@ -5,11 +5,13 @@ import 'zod';
 import { createWebInquiryActions } from './features/inquiry/actions.js';
 import { createWebConfigActions } from './resources/config/actions.js';
 import { createWebPostActions } from './resources/post/actions.js';
+import { createWebPageActions } from './resources/page/actions.js';
 
 function createWebServer({
   siteroServer,
   staticTopics
 }) {
+  const page = createWebPageActions({ siteroServer });
   const config = createWebConfigActions({ siteroServer });
   const inquiry = createWebInquiryActions({
     siteroServer,
@@ -22,13 +24,15 @@ function createWebServer({
         inquiry
       },
       resources: {
+        page: page.actions,
         config: config.actions,
         post: post.actions
       }
     },
     loaders: {
       ...config.loaders,
-      ...post.loaders
+      ...post.loaders,
+      ...page.loaders
     }
   };
 }

package/dist/src/web/server/resources/page/actions.js

@@ -0,0 +1,20 @@
+import { operationResult, PageUnavailableError } from 'sitero-server';
+
+function createWebPageActions({
+  siteroServer
+}) {
+  const findDetail = async (input) => {
+    const page = siteroServer.resources.page;
+    if (!page) return operationResult.failure(new PageUnavailableError());
+    return siteroServer.executor.execute(page.findDetail, input, {});
+  };
+  const loadPage = async ({ pageSlug }) => {
+    const result = await findDetail({ key: pageSlug });
+    if (result.success) return { page: result.data.page };
+    if (result.error.code === "PAGE_NOT_FOUND") return { page: void 0 };
+    throw new Error(`[page.loadPage] ${result.error.code}`);
+  };
+  return { actions: { findDetail }, loaders: { loadPage } };
+}
+
+export { createWebPageActions };