sitero-server 0.5.0 → 0.7.0

package/dist/export/index.js

@@ -20,3 +20,13 @@ export { isStorageFile } from '../src/contracts/storage/file.js';
 export { createAdminForgotPasswordEmailSender } from '../src/application/email/authentication/admin/forgot-password/send.js';
 export { createAdminVerificationEmailSender } from '../src/application/email/authentication/admin/verify-email/send.js';
 export { createNewInquiryEmailSender } from '../src/application/email/inquiry/new-inquiry/send.js';
+export { PAGE_ERROR_CODES } from '../src/application/resources/page/errors/codes.js';
+export { PageMediaTypeInvalidError, PageNotFoundError, PageUnavailableError } from '../src/application/resources/page/errors/operation-errors.js';
+export { createPageFindDetailQuery } from '../src/application/resources/page/operations/queries/find-detail/page-find-detail-query.js';
+export { createPageFindManyQuery } from '../src/application/resources/page/operations/queries/find-many/page-find-many-query.js';
+export { createPageUpdateCommand } from '../src/application/resources/page/operations/commands/update/page-update-command.js';
+export { SEO_METADATA_ERROR_CODES } from '../src/application/resources/seo-metadata/errors/codes.js';
+export { SeoMetadataPageNotFoundError, SeoMetadataPageUnavailableError, SeoMetadataPostNotFoundError } from '../src/application/resources/seo-metadata/errors/operation-errors.js';
+import '../src/application/resources/seo-metadata/operations/commands/upsert/validation/schema.js';
+export { POST_ERROR_CODES } from '../src/application/resources/post/errors/codes.js';
+import '../src/application/resources/post/operations/commands/create/validation/schema.js';

package/dist/src/application/resources/file/operations/queries/find-detail/cache.js

@@ -2,6 +2,9 @@ import { createCacheKey } from '../../../../../conventions/cache/cache-key.js';
 import { createResourceTag } from '../../../../../conventions/cache/cache-tag.js';
 
 const createFileFindDetailCacheKey = (input) => createCacheKey("file", "find-detail", { id: input.id });
-const createFileFindDetailCacheTags = (_, result) => [createResourceTag("file", { id: result.data.file.id })].flat();
+const createFileFindDetailCacheTags = (_, result) => [
+  createResourceTag("post"),
+  createResourceTag("file", { id: result.data.file.id })
+].flat();
 
 export { createFileFindDetailCacheKey, createFileFindDetailCacheTags };

package/dist/src/application/resources/file/operations/queries/find-list-cards/cache.js

@@ -16,6 +16,7 @@ const createFileFindListCardsCacheTags = (_, result) => [
   ...new Set(
     [
       createResourceTag("file"),
+      createResourceTag("post"),
       ...result.data.items.map(
         (file) => createResourceTag("file", { id: file.id })
       )

package/dist/src/application/resources/file/operations/queries/find-relations/cache.js

@@ -2,6 +2,9 @@ import { createCacheKey } from '../../../../../conventions/cache/cache-key.js';
 import { createResourceTag } from '../../../../../conventions/cache/cache-tag.js';
 
 const createFileFindRelationsCacheKey = (input) => createCacheKey("file", "find-relations", { id: input.id });
-const createFileFindRelationsCacheTags = (input) => [createResourceTag("file", { id: input.id })].flat();
+const createFileFindRelationsCacheTags = (input) => [
+  createResourceTag("post"),
+  createResourceTag("file", { id: input.id })
+].flat();
 
 export { createFileFindRelationsCacheKey, createFileFindRelationsCacheTags };

package/dist/src/application/resources/page/collect-page-file-ids.js

@@ -0,0 +1,14 @@
+import { PAGE_MEDIA_FIELDS } from 'sitero-domain';
+
+function collectPageFileIds(page) {
+  return [
+    ...new Set(
+      PAGE_MEDIA_FIELDS.flatMap((field) => {
+        const id = page[`${field}Id`];
+        return id ? [id] : [];
+      })
+    )
+  ];
+}
+
+export { collectPageFileIds };

package/dist/src/application/resources/page/errors/codes.js

@@ -0,0 +1,7 @@
+const PAGE_ERROR_CODES = {
+  UNAVAILABLE: "PAGE_UNAVAILABLE",
+  NOT_FOUND: "PAGE_NOT_FOUND",
+  MEDIA_TYPE_INVALID: "PAGE_MEDIA_TYPE_INVALID"
+};
+
+export { PAGE_ERROR_CODES };

package/dist/src/application/resources/page/errors/operation-errors.js

@@ -0,0 +1,23 @@
+import { OperationError } from '../../../../contracts/operation/error.js';
+import { PAGE_ERROR_CODES } from './codes.js';
+
+class PageNotFoundError extends OperationError {
+  constructor() {
+    super({ code: PAGE_ERROR_CODES.NOT_FOUND });
+    this.name = "PageNotFoundError";
+  }
+}
+class PageMediaTypeInvalidError extends OperationError {
+  constructor() {
+    super({ code: PAGE_ERROR_CODES.MEDIA_TYPE_INVALID });
+    this.name = "PageMediaTypeInvalidError";
+  }
+}
+class PageUnavailableError extends OperationError {
+  constructor() {
+    super({ code: PAGE_ERROR_CODES.UNAVAILABLE });
+    this.name = "PageUnavailableError";
+  }
+}
+
+export { PageMediaTypeInvalidError, PageNotFoundError, PageUnavailableError };

package/dist/src/application/resources/page/operations/commands/update/cache.js

@@ -0,0 +1,23 @@
+import { createResourceTag, createRelationTag } from '../../../../../conventions/cache/cache-tag.js';
+import { collectPageFileIds } from '../../../collect-page-file-ids.js';
+
+const createPageUpdateInvalidationTags = (input, result) => {
+  const pages = [input.previous, result.data.page];
+  const fileIds = /* @__PURE__ */ new Set([
+    ...collectPageFileIds(input.previous),
+    ...collectPageFileIds(result.data.page)
+  ]);
+  const tags = [
+    createResourceTag("page"),
+    ...pages.flatMap((page) => [
+      createResourceTag("page", { id: page.id }),
+      createResourceTag("page", { key: page.key }),
+      // Main and section cover media references.
+      createRelationTag("page", "file", { id: page.id })
+    ]),
+    ...[...fileIds].map((id) => createResourceTag("file", { id }))
+  ].flat();
+  return [...new Set(tags)];
+};
+
+export { createPageUpdateInvalidationTags };

package/dist/src/application/resources/page/operations/commands/update/page-update-command.js

@@ -0,0 +1,36 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { createPageUpdateInvalidationTags } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+function createPageUpdateCommand(input) {
+  const { authorization, pageQueryPort, pageCommandPort, fileQueryPort } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "command",
+        invalidate: {
+          tags: createPageUpdateInvalidationTags
+        }
+      },
+      async validate(input2) {
+        return validateInput({
+          input: input2,
+          pageQueryPort,
+          fileQueryPort
+        });
+      }
+    },
+    async (input2) => {
+      const { previous: _, ...writeInput } = input2;
+      const page = await pageCommandPort.update(writeInput);
+      return operationResult.success({
+        page
+      });
+    }
+  );
+}
+
+export { createPageUpdateCommand };

package/dist/src/application/resources/page/operations/commands/update/validation/schema.js

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import { addDuplicateLocaleIssues } from '../../../../../../conventions/validation/add-duplicate-locale-issues.js';
+import { textSchema, requiredTextSchema, idSchema } from '../../../../../../conventions/validation/schema.js';
+
+const pageUpdateInputSchema = () => z.object({
+  id: idSchema(),
+  page: z.object({
+    coverMediaId: idSchema().nullable().optional(),
+    section1CoverMediaId: idSchema().nullable().optional(),
+    section2CoverMediaId: idSchema().nullable().optional(),
+    section3CoverMediaId: idSchema().nullable().optional(),
+    section4CoverMediaId: idSchema().nullable().optional(),
+    section5CoverMediaId: idSchema().nullable().optional(),
+    section6CoverMediaId: idSchema().nullable().optional(),
+    section7CoverMediaId: idSchema().nullable().optional(),
+    section8CoverMediaId: idSchema().nullable().optional(),
+    section9CoverMediaId: idSchema().nullable().optional(),
+    section10CoverMediaId: idSchema().nullable().optional(),
+    translations: z.array(
+      z.object({
+        locale: requiredTextSchema(),
+        title: textSchema().nullable().optional(),
+        subtitle: textSchema().nullable().optional(),
+        description: textSchema().nullable().optional(),
+        text1: textSchema().nullable().optional(),
+        text2: textSchema().nullable().optional(),
+        text3: textSchema().nullable().optional(),
+        text4: textSchema().nullable().optional(),
+        section1Title: textSchema().nullable().optional(),
+        section1Subtitle: textSchema().nullable().optional(),
+        section1Description: textSchema().nullable().optional(),
+        section1Text1: textSchema().nullable().optional(),
+        section1Text2: textSchema().nullable().optional(),
+        section1Text3: textSchema().nullable().optional(),
+        section1Text4: textSchema().nullable().optional(),
+        section2Title: textSchema().nullable().optional(),
+        section2Subtitle: textSchema().nullable().optional(),
+        section2Description: textSchema().nullable().optional(),
+        section2Text1: textSchema().nullable().optional(),
+        section2Text2: textSchema().nullable().optional(),
+        section2Text3: textSchema().nullable().optional(),
+        section2Text4: textSchema().nullable().optional(),
+        section3Title: textSchema().nullable().optional(),
+        section3Subtitle: textSchema().nullable().optional(),
+        section3Description: textSchema().nullable().optional(),
+        section3Text1: textSchema().nullable().optional(),
+        section3Text2: textSchema().nullable().optional(),
+        section3Text3: textSchema().nullable().optional(),
+        section3Text4: textSchema().nullable().optional(),
+        section4Title: textSchema().nullable().optional(),
+        section4Subtitle: textSchema().nullable().optional(),
+        section4Description: textSchema().nullable().optional(),
+        section4Text1: textSchema().nullable().optional(),
+        section4Text2: textSchema().nullable().optional(),
+        section4Text3: textSchema().nullable().optional(),
+        section4Text4: textSchema().nullable().optional(),
+        section5Title: textSchema().nullable().optional(),
+        section5Subtitle: textSchema().nullable().optional(),
+        section5Description: textSchema().nullable().optional(),
+        section5Text1: textSchema().nullable().optional(),
+        section5Text2: textSchema().nullable().optional(),
+        section5Text3: textSchema().nullable().optional(),
+        section5Text4: textSchema().nullable().optional(),
+        section6Title: textSchema().nullable().optional(),
+        section6Subtitle: textSchema().nullable().optional(),
+        section6Description: textSchema().nullable().optional(),
+        section6Text1: textSchema().nullable().optional(),
+        section6Text2: textSchema().nullable().optional(),
+        section6Text3: textSchema().nullable().optional(),
+        section6Text4: textSchema().nullable().optional(),
+        section7Title: textSchema().nullable().optional(),
+        section7Subtitle: textSchema().nullable().optional(),
+        section7Description: textSchema().nullable().optional(),
+        section7Text1: textSchema().nullable().optional(),
+        section7Text2: textSchema().nullable().optional(),
+        section7Text3: textSchema().nullable().optional(),
+        section7Text4: textSchema().nullable().optional(),
+        section8Title: textSchema().nullable().optional(),
+        section8Subtitle: textSchema().nullable().optional(),
+        section8Description: textSchema().nullable().optional(),
+        section8Text1: textSchema().nullable().optional(),
+        section8Text2: textSchema().nullable().optional(),
+        section8Text3: textSchema().nullable().optional(),
+        section8Text4: textSchema().nullable().optional(),
+        section9Title: textSchema().nullable().optional(),
+        section9Subtitle: textSchema().nullable().optional(),
+        section9Description: textSchema().nullable().optional(),
+        section9Text1: textSchema().nullable().optional(),
+        section9Text2: textSchema().nullable().optional(),
+        section9Text3: textSchema().nullable().optional(),
+        section9Text4: textSchema().nullable().optional(),
+        section10Title: textSchema().nullable().optional(),
+        section10Subtitle: textSchema().nullable().optional(),
+        section10Description: textSchema().nullable().optional(),
+        section10Text1: textSchema().nullable().optional(),
+        section10Text2: textSchema().nullable().optional(),
+        section10Text3: textSchema().nullable().optional(),
+        section10Text4: textSchema().nullable().optional()
+      }).strict()
+    ).min(1).superRefine(addDuplicateLocaleIssues)
+  }).strict()
+}).strict();
+
+export { pageUpdateInputSchema };

package/dist/src/application/resources/page/operations/commands/update/validation/validate-input.js

@@ -0,0 +1,25 @@
+import { FILE_TYPES } from 'sitero-domain';
+import { FileNotFoundError } from '../../../../../file/errors/operation-errors.js';
+import 'zod';
+import 'p-limit';
+import { collectPageFileIds } from '../../../../collect-page-file-ids.js';
+import { PageNotFoundError, PageMediaTypeInvalidError } from '../../../../errors/operation-errors.js';
+import { pageUpdateInputSchema } from './schema.js';
+
+async function validateInput(input) {
+  const parsed = pageUpdateInputSchema().parse(input.input);
+  const previous = await input.pageQueryPort.findDetail({ id: parsed.id });
+  if (!previous) throw new PageNotFoundError();
+  await Promise.all(
+    collectPageFileIds(parsed.page).map(async (id) => {
+      const file = await input.fileQueryPort.find({ id });
+      if (!file || file.deletedAt || file.purgeStartedAt)
+        throw new FileNotFoundError();
+      if (file.type !== FILE_TYPES.IMAGE && file.type !== FILE_TYPES.VIDEO)
+        throw new PageMediaTypeInvalidError();
+    })
+  );
+  return { ...parsed, previous };
+}
+
+export { validateInput };

package/dist/src/application/resources/page/operations/queries/find-detail/cache.js

@@ -0,0 +1,28 @@
+import { createCacheKey } from '../../../../../conventions/cache/cache-key.js';
+import { createResourceTag, createRelationTag } from '../../../../../conventions/cache/cache-tag.js';
+import { collectPageFileIds } from '../../../collect-page-file-ids.js';
+
+const createPageFindDetailCacheKey = (input) => {
+  return createCacheKey(
+    "page",
+    "find-detail",
+    input.id !== void 0 ? { id: input.id } : { key: input.key }
+  );
+};
+const createPageFindDetailCacheTags = (_, result) => {
+  const { page } = result.data;
+  const fileIds = collectPageFileIds(page);
+  return [
+    createResourceTag("page", { id: page.id }),
+    createResourceTag("page", { key: page.key }),
+    // Main and section cover media references.
+    ...fileIds.map((fileId) => createResourceTag("file", { id: fileId })),
+    createRelationTag("page", "file", { id: page.id }),
+    createRelationTag("page", "seo-metadata", { id: page.id }),
+    ...page.seoMetadatas.map(
+      (seo) => createResourceTag("seo-metadata", { id: seo.id })
+    )
+  ].flat();
+};
+
+export { createPageFindDetailCacheKey, createPageFindDetailCacheTags };

package/dist/src/application/resources/page/operations/queries/find-detail/page-find-detail-query.js

@@ -0,0 +1,35 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { PageNotFoundError } from '../../../errors/operation-errors.js';
+import { createPageFindDetailCacheTags, createPageFindDetailCacheKey } from './cache.js';
+import { pageFindDetailInputSchema } from './validation/schema.js';
+
+function createPageFindDetailQuery(input) {
+  const { pageQueryPort } = input;
+  return createOperation(
+    {
+      behavior: {
+        kind: "query",
+        cache: {
+          key: createPageFindDetailCacheKey,
+          tags: createPageFindDetailCacheTags
+        }
+      },
+      validate(input2) {
+        return pageFindDetailInputSchema().parse(input2);
+      }
+    },
+    async (input2) => {
+      const page = await pageQueryPort.findDetail(input2);
+      if (!page) {
+        return operationResult.failure(new PageNotFoundError());
+      }
+      return operationResult.success({
+        page
+      });
+    }
+  );
+}
+
+export { createPageFindDetailQuery };

package/dist/src/application/resources/page/operations/queries/find-detail/validation/schema.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { idSchema, requiredTextSchema } from '../../../../../../conventions/validation/schema.js';
+
+const pageFindDetailInputSchema = () => z.union([
+  z.object({ id: idSchema() }).strict(),
+  z.object({ key: requiredTextSchema() }).strict()
+]);
+
+export { pageFindDetailInputSchema };

package/dist/src/application/resources/page/operations/queries/find-many/cache.js

@@ -0,0 +1,17 @@
+import { createCacheKey, normalizeSelection } from '../../../../../conventions/cache/cache-key.js';
+import { createResourceTag } from '../../../../../conventions/cache/cache-tag.js';
+
+const createPageFindManyCacheKey = (input) => createCacheKey("page", "find-many", {
+  keys: normalizeSelection(input?.keys)
+});
+const createPageFindManyCacheTags = (input, result) => input?.keys?.length === 0 ? [] : [
+  .../* @__PURE__ */ new Set([
+    ...createResourceTag("page"),
+    ...result.data.pages.flatMap((page) => [
+      ...createResourceTag("page", { id: page.id }),
+      ...createResourceTag("page", { key: page.key })
+    ])
+  ])
+];
+
+export { createPageFindManyCacheKey, createPageFindManyCacheTags };

package/dist/src/application/resources/page/operations/queries/find-many/page-find-many-query.js

@@ -0,0 +1,35 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { createPageFindManyCacheTags, createPageFindManyCacheKey } from './cache.js';
+import { validatePageFindManyInput } from './validation/validate-input.js';
+
+function createPageFindManyQuery(input) {
+  const { pageQueryPort, authorization } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "query",
+        cache: {
+          key: createPageFindManyCacheKey,
+          tags: createPageFindManyCacheTags
+        }
+      },
+      validate(input2) {
+        return validatePageFindManyInput(input2);
+      }
+    },
+    async (input2) => {
+      if (input2?.keys?.length === 0) {
+        return operationResult.success({ pages: [] });
+      }
+      const pages = await pageQueryPort.findMany(input2);
+      return operationResult.success({
+        pages
+      });
+    }
+  );
+}
+
+export { createPageFindManyQuery };

package/dist/src/application/resources/page/operations/queries/find-many/validation/schema.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { requiredTextSchema } from '../../../../../../conventions/validation/schema.js';
+
+const pageFindManyInputSchema = () => z.object({
+  keys: z.array(requiredTextSchema()).optional()
+}).optional();
+
+export { pageFindManyInputSchema };

package/dist/src/application/resources/page/operations/queries/find-many/validation/validate-input.js

@@ -0,0 +1,12 @@
+import { normalizeStringSelection } from '../../../../../../conventions/normalization/normalize-string-selection.js';
+import { pageFindManyInputSchema } from './schema.js';
+
+function validatePageFindManyInput(input) {
+  const parsedInput = pageFindManyInputSchema().parse(input);
+  if (!parsedInput || parsedInput.keys === void 0) {
+    return void 0;
+  }
+  return { keys: normalizeStringSelection(parsedInput.keys) };
+}
+
+export { validatePageFindManyInput };

package/dist/src/application/resources/post/assert-post-write-relations-exist.js

@@ -32,7 +32,6 @@ async function assertPostWriteRelationsExist(input) {
     })
   );
   const postIds = [
-    relations.topic?.id,
     ...relations.parents.map((item) => item.id),
     ...relations.tags.map((item) => item.id),
     ...relations.relatedPosts.map((item) => item.id)

package/dist/src/application/resources/post/collect-post-reference-ids.js

@@ -1,13 +1,11 @@
 function collectPostReferenceIds(post) {
   return [
-    post.topic?.id,
     ...post.parents.map((item) => item.id),
     ...post.children.map((item) => item.id),
     ...post.tags.map((item) => item.id),
     ...post.taggedPosts.map((item) => item.id),
     ...post.relatedPosts.map((item) => item.id),
-    ...post.referencingPosts.map((item) => item.id),
-    ...post.postsInTopic.map((item) => item.id)
+    ...post.referencingPosts.map((item) => item.id)
   ].filter((id) => Boolean(id));
 }
 

package/dist/src/application/resources/post/create-post-list-card-cache-tags.js

@@ -0,0 +1,19 @@
+import { createResourceTag, createRelationTag } from '../../conventions/cache/cache-tag.js';
+
+function createPostListCardCacheTags(post) {
+  return [
+    createResourceTag("post", { id: post.id }),
+    createRelationTag("post", "parent", { id: post.id }),
+    ...post.parents.flatMap((parent) => [
+      createResourceTag("post", { id: parent.id }),
+      createRelationTag("post", "cover-image", { id: parent.id }),
+      ...parent.coverImage ? [createResourceTag("file", { id: parent.coverImage.id })] : []
+    ]),
+    ...post.coverImage ? [
+      createResourceTag("file", { id: post.coverImage.id }),
+      createRelationTag("post", "cover-image", { id: post.id })
+    ] : []
+  ].flat();
+}
+
+export { createPostListCardCacheTags };

package/dist/src/application/resources/post/errors/codes.js

@@ -1,5 +1,11 @@
 const POST_ERROR_CODES = {
   NOT_FOUND: "POST_NOT_FOUND",
+  IN_USE: "POST_IN_USE",
+  INVALID_STATE: "POST_INVALID_STATE",
+  SLUG_CONFLICT: "POST_SLUG_CONFLICT",
+  PARENT_UNPUBLISHED: "POST_PARENT_UNPUBLISHED",
+  HAS_PUBLISHED_CHILDREN: "POST_HAS_PUBLISHED_CHILDREN",
+  REFERENCE_UNAVAILABLE: "POST_REFERENCE_UNAVAILABLE",
   DELETE_LOCKED: "POST_DELETE_LOCKED"
 };
 const POST_FIELD_ERROR_CODES = {

package/dist/src/application/resources/post/operations/commands/create/cache.js

@@ -3,7 +3,6 @@ import { createResourceTag, createRelationTag } from '../../../../../conventions
 const createPostCreateInvalidationTags = (input, result) => {
   const { post } = result.data;
   const postIds = [
-    input.topic?.id,
     ...input.parents.map((item) => item.id),
     ...input.tags.map((item) => item.id),
     ...input.relatedPosts.map((item) => item.id)

package/dist/src/application/resources/post/operations/commands/create/post-create-command.js

@@ -6,6 +6,7 @@ import { validateInput } from './validation/validate-input.js';
 
 function createPostCreateCommand(input) {
   const {
+    topics = {},
     authorization,
     postCommandPort,
     postQueryPort,
@@ -22,6 +23,7 @@ function createPostCreateCommand(input) {
       async validate(input2) {
         return validateInput({
           input: input2,
+          topics,
           postQueryPort,
           adminQueryPort,
           fileQueryPort

package/dist/src/application/resources/post/operations/commands/create/validation/schema.js

@@ -62,7 +62,7 @@ const postCreateInputSchema = () => z.object({
   int3: nullableInteger,
   int4: nullableInteger,
   author: singleItemSchema(),
-  topic: singleItemSchema(),
+  topicKey: requiredTextSchema().nullable(),
   parents: multiItemsSchema(),
   tags: multiItemsSchema(),
   relatedPosts: multiItemsSchema(),

package/dist/src/application/resources/post/operations/commands/create/validation/validate-input.js

@@ -1,5 +1,6 @@
 import { normalizeStringSelection } from '../../../../../../conventions/normalization/normalize-string-selection.js';
 import { assertPostWriteRelationsExist } from '../../../../assert-post-write-relations-exist.js';
+import { validatePostTopic } from '../../../../validate-topic.js';
 import { postCreateInputSchema } from './schema.js';
 
 async function validateInput(input) {
@@ -22,6 +23,13 @@ async function validateInput(input) {
     files1: normalizeItems(validatedInput.files1),
     files2: normalizeItems(validatedInput.files2)
   };
+  await validatePostTopic({
+    type: preparedInput.type,
+    topicKey: preparedInput.topicKey,
+    parents: preparedInput.parents,
+    topics: input.topics,
+    postQueryPort
+  });
   await assertPostWriteRelationsExist({
     relations: preparedInput,
     adminQueryPort,

package/dist/src/application/resources/post/operations/commands/delete/cache.js

@@ -17,7 +17,6 @@ const createPostDeleteInvalidationTags = (input, result) => {
         ),
         ...previous.author ? [createResourceTag("admin", { id: previous.author.id })] : [],
         createRelationTag("post", "author", { id: previous.id }),
-        createRelationTag("post", "topic", { id: previous.id }),
         createRelationTag("post", "parent", { id: previous.id }),
         createRelationTag("post", "tag", { id: previous.id }),
         createRelationTag("post", "related-post", { id: previous.id }),

package/dist/src/application/resources/post/operations/commands/lifecycle.js

@@ -0,0 +1,32 @@
+import { createOperation } from '../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../contracts/operation/result.js';
+import { PostNotFoundError } from '../../errors/operation-errors.js';
+import { createPostDeleteInvalidationTags } from './delete/cache.js';
+import { postDeleteInputSchema } from './delete/validation/schema.js';
+
+function createPostLifecycleCommand(input) {
+  return createOperation(
+    {
+      authorization: input.authorization,
+      behavior: {
+        kind: "command",
+        invalidate: { tags: createPostDeleteInvalidationTags }
+      },
+      async validate(raw) {
+        const parsed = postDeleteInputSchema().parse(raw);
+        const { post: previous } = await input.postQueryPort.findDetail({
+          ...parsed,
+          deletion: "deleted"
+        });
+        if (!previous) throw new PostNotFoundError();
+        return { ...parsed, previous };
+      }
+    },
+    async ({ id }) => operationResult.success({
+      post: await input.postCommandPort[input.action]({ id })
+    })
+  );
+}
+
+export { createPostLifecycleCommand };

package/dist/src/application/resources/post/operations/commands/update/cache.js

@@ -6,7 +6,6 @@ const createPostUpdateInvalidationTags = (input, result) => {
   const { previous } = input;
   const postIds = [
     ...collectPostReferenceIds(previous),
-    input.topic?.id,
     ...input.parents.map((item) => item.id),
     ...input.tags.map((item) => item.id),
     ...input.relatedPosts.map((item) => item.id)
@@ -32,7 +31,6 @@ const createPostUpdateInvalidationTags = (input, result) => {
         ...previous.author ? [createResourceTag("admin", { id: previous.author.id })] : [],
         ...input.author ? [createResourceTag("admin", { id: input.author.id })] : [],
         createRelationTag("post", "author", { id: input.id }),
-        createRelationTag("post", "topic", { id: input.id }),
         createRelationTag("post", "parent", { id: input.id }),
         createRelationTag("post", "tag", { id: input.id }),
         createRelationTag("post", "related-post", { id: input.id }),

package/dist/src/application/resources/post/operations/commands/update/post-update-command.js

@@ -6,6 +6,7 @@ import { validateInput } from './validation/validate-input.js';
 
 function createPostUpdateCommand(input) {
   const {
+    topics = {},
     authorization,
     postCommandPort,
     postQueryPort,
@@ -22,6 +23,7 @@ function createPostUpdateCommand(input) {
       async validate(input2) {
         return validateInput({
           input: input2,
+          topics,
           postQueryPort,
           adminQueryPort,
           fileQueryPort

package/dist/src/application/resources/post/operations/commands/update/validation/schema.js

@@ -1,6 +1,6 @@
 import { idSchema } from '../../../../../../conventions/validation/schema.js';
 import { postCreateInputSchema } from '../../create/validation/schema.js';
 
-const postUpdateInputSchema = () => postCreateInputSchema().omit({ type: true }).extend({ id: idSchema() }).strict();
+const postUpdateInputSchema = () => postCreateInputSchema().omit({ type: true, topicKey: true }).extend({ id: idSchema() }).strict();
 
 export { postUpdateInputSchema };