sitero-server 0.0.1

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

@@ -0,0 +1,39 @@
+import { createResourceTag, createRelationTag } from '../../../../../conventions/cache/cache-tag.js';
+
+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)
+  ];
+  const fileIds = [
+    input.coverImage?.id,
+    ...input.contentImages.map((item) => item.id),
+    ...input.files1.map((item) => item.id),
+    ...input.files2.map((item) => item.id),
+    input.file1?.id,
+    input.file2?.id,
+    input.file3?.id,
+    input.file4?.id
+  ];
+  return [
+    ...new Set(
+      [
+        createResourceTag("post"),
+        createResourceTag("post", { id: post.id }),
+        ...input.author ? [
+          createResourceTag("admin", { id: input.author.id }),
+          createRelationTag("post", "author", { id: post.id })
+        ] : [],
+        ...postIds.flatMap((id) => [createResourceTag("post", { id })]),
+        ...fileIds.flatMap(
+          (id) => id ? createResourceTag("file", { id }) : []
+        )
+      ].flat()
+    )
+  ];
+};
+
+export { createPostCreateInvalidationTags };

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

@@ -0,0 +1,38 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { createPostCreateInvalidationTags } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+function createPostCreateCommand(input) {
+  const {
+    authorization,
+    postCommandPort,
+    postQueryPort,
+    adminQueryPort,
+    fileQueryPort
+  } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "command",
+        invalidate: { tags: createPostCreateInvalidationTags }
+      },
+      async validate(input2) {
+        return validateInput({
+          input: input2,
+          postQueryPort,
+          adminQueryPort,
+          fileQueryPort
+        });
+      }
+    },
+    async (input2) => {
+      const post = await postCommandPort.create(input2);
+      return operationResult.success({ post });
+    }
+  );
+}
+
+export { createPostCreateCommand };

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

@@ -0,0 +1,95 @@
+import { POST_TYPES } from 'sitero-domain';
+import { z } from 'zod';
+import { addDuplicateLocaleIssues } from '../../../../../../conventions/validation/add-duplicate-locale-issues.js';
+import { textSchema, requiredTextSchema, singleItemSchema, multiItemsSchema } from '../../../../../../conventions/validation/schema.js';
+
+const nullableText = textSchema().nullable();
+const nullableNumber = z.number().nullable();
+const nullableInteger = z.number().int().nullable();
+const data = z.array(z.any());
+const postCreateInputSchema = () => z.object({
+  type: z.enum(POST_TYPES),
+  isActive: z.boolean(),
+  isIndexActive: z.boolean(),
+  index: nullableInteger,
+  isSlugActive: z.boolean(),
+  slug: nullableText,
+  isFeatured: z.boolean(),
+  isShownOnHome: z.boolean(),
+  state1: z.boolean(),
+  state2: z.boolean(),
+  state3: z.boolean(),
+  state4: z.boolean(),
+  state5: z.boolean(),
+  state6: z.boolean(),
+  state7: z.boolean(),
+  state8: z.boolean(),
+  state9: z.boolean(),
+  state10: z.boolean(),
+  text1: nullableText,
+  text2: nullableText,
+  text3: nullableText,
+  text4: nullableText,
+  text5: nullableText,
+  text6: nullableText,
+  text7: nullableText,
+  text8: nullableText,
+  text9: nullableText,
+  text10: nullableText,
+  data1: data,
+  data2: data,
+  data3: data,
+  data4: data,
+  dec1: nullableNumber,
+  dec2: nullableNumber,
+  dec3: nullableNumber,
+  dec4: nullableNumber,
+  int1: nullableInteger,
+  int2: nullableInteger,
+  int3: nullableInteger,
+  int4: nullableInteger,
+  author: singleItemSchema(),
+  topic: singleItemSchema(),
+  parents: multiItemsSchema(),
+  tags: multiItemsSchema(),
+  relatedPosts: multiItemsSchema(),
+  coverImage: singleItemSchema(),
+  contentImages: multiItemsSchema(),
+  files1: multiItemsSchema(),
+  files2: multiItemsSchema(),
+  file1: singleItemSchema(),
+  file2: singleItemSchema(),
+  file3: singleItemSchema(),
+  file4: singleItemSchema(),
+  translations: z.array(
+    z.object({
+      locale: requiredTextSchema(),
+      title: nullableText,
+      subtitle: nullableText,
+      summary: nullableText,
+      description: nullableText,
+      content: nullableText,
+      externalLinks: data,
+      faq: data,
+      toc: data,
+      readTime: nullableNumber,
+      wordCount: z.number().int().nonnegative(),
+      text1: nullableText,
+      text2: nullableText,
+      text3: nullableText,
+      text4: nullableText,
+      text5: nullableText,
+      text6: nullableText,
+      text7: nullableText,
+      text8: nullableText,
+      text9: nullableText,
+      text10: nullableText,
+      data1: data,
+      data2: data,
+      data3: data,
+      data4: data
+    })
+  ).min(1).superRefine(addDuplicateLocaleIssues)
+}).strict();
+
+export { postCreateInputSchema };

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

@@ -0,0 +1,34 @@
+import { normalizeStringSelection } from '../../../../../../conventions/normalization/normalize-string-selection.js';
+import { assertPostWriteRelationsExist } from '../../../../assert-post-write-relations-exist.js';
+import { postCreateInputSchema } from './schema.js';
+
+async function validateInput(input) {
+  const {
+    input: rawInput,
+    adminQueryPort,
+    fileQueryPort,
+    postQueryPort
+  } = input;
+  const validatedInput = postCreateInputSchema().parse(rawInput);
+  const normalizeItems = (items) => normalizeStringSelection(items.map((item) => item.id)).map((id) => ({
+    id
+  }));
+  const preparedInput = {
+    ...validatedInput,
+    parents: normalizeItems(validatedInput.parents),
+    tags: normalizeItems(validatedInput.tags),
+    relatedPosts: normalizeItems(validatedInput.relatedPosts),
+    contentImages: normalizeItems(validatedInput.contentImages),
+    files1: normalizeItems(validatedInput.files1),
+    files2: normalizeItems(validatedInput.files2)
+  };
+  await assertPostWriteRelationsExist({
+    relations: preparedInput,
+    adminQueryPort,
+    fileQueryPort,
+    postQueryPort
+  });
+  return preparedInput;
+}
+
+export { validateInput };

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

@@ -0,0 +1,32 @@
+import { createResourceTag, createRelationTag } from '../../../../../conventions/cache/cache-tag.js';
+import { collectPostFileIds } from '../../../collect-post-file-ids.js';
+import { collectPostReferenceIds } from '../../../collect-post-reference-ids.js';
+
+const createPostDeleteInvalidationTags = (input, result) => {
+  const { previous } = input;
+  return [
+    ...new Set(
+      [
+        createResourceTag("post"),
+        createResourceTag("post", { id: result.data.post.id }),
+        ...collectPostReferenceIds(previous).map(
+          (id) => createResourceTag("post", { id })
+        ),
+        ...collectPostFileIds(previous).map(
+          (id) => createResourceTag("file", { id })
+        ),
+        ...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 }),
+        createRelationTag("post", "cover-image", { id: previous.id }),
+        createRelationTag("post", "content-image", { id: previous.id }),
+        createRelationTag("post", "file", { id: previous.id })
+      ].flat()
+    )
+  ];
+};
+
+export { createPostDeleteInvalidationTags };

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

@@ -0,0 +1,27 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { createPostDeleteInvalidationTags } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+function createPostDeleteCommand(input) {
+  const { authorization, postCommandPort, postQueryPort } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "command",
+        invalidate: { tags: createPostDeleteInvalidationTags }
+      },
+      async validate(input2) {
+        return validateInput({ input: input2, postQueryPort });
+      }
+    },
+    async ({ id }) => {
+      const post = await postCommandPort.delete({ id });
+      return operationResult.success({ post });
+    }
+  );
+}
+
+export { createPostDeleteCommand };

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { idSchema } from '../../../../../../conventions/validation/schema.js';
+
+const postDeleteInputSchema = () => z.object({
+  id: idSchema()
+}).strict();
+
+export { postDeleteInputSchema };

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

@@ -0,0 +1,19 @@
+import { PostNotFoundError, PostDeleteLockedError } from '../../../../errors/operation-errors.js';
+import { postDeleteInputSchema } from './schema.js';
+
+async function validateInput(input) {
+  const validatedInput = postDeleteInputSchema().parse(input.input);
+  const previousResult = await input.postQueryPort.findDetail({
+    id: validatedInput.id
+  });
+  const previous = previousResult.post;
+  if (!previous) {
+    throw new PostNotFoundError();
+  }
+  if (previous.isLocked) {
+    throw new PostDeleteLockedError();
+  }
+  return { ...validatedInput, previous };
+}
+
+export { validateInput };

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

@@ -0,0 +1,47 @@
+import { createResourceTag, createRelationTag } from '../../../../../conventions/cache/cache-tag.js';
+import { collectPostFileIds } from '../../../collect-post-file-ids.js';
+import { collectPostReferenceIds } from '../../../collect-post-reference-ids.js';
+
+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)
+  ];
+  const fileIds = [
+    ...collectPostFileIds(previous),
+    input.coverImage?.id,
+    ...input.contentImages.map((item) => item.id),
+    ...input.files1.map((item) => item.id),
+    ...input.files2.map((item) => item.id),
+    input.file1?.id,
+    input.file2?.id,
+    input.file3?.id,
+    input.file4?.id
+  ].filter((id) => id !== void 0);
+  return [
+    ...new Set(
+      [
+        createResourceTag("post"),
+        createResourceTag("post", { id: result.data.post.id }),
+        ...postIds.map((id) => createResourceTag("post", { id })),
+        ...fileIds.map((id) => createResourceTag("file", { id })),
+        ...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 }),
+        createRelationTag("post", "cover-image", { id: input.id }),
+        createRelationTag("post", "content-image", { id: input.id }),
+        createRelationTag("post", "file", { id: input.id })
+      ].flat()
+    )
+  ];
+};
+
+export { createPostUpdateInvalidationTags };

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

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

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

@@ -0,0 +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();
+
+export { postUpdateInputSchema };

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

@@ -0,0 +1,42 @@
+import { normalizeStringSelection } from '../../../../../../conventions/normalization/normalize-string-selection.js';
+import { assertPostWriteRelationsExist } from '../../../../assert-post-write-relations-exist.js';
+import { PostNotFoundError } from '../../../../errors/operation-errors.js';
+import { postUpdateInputSchema } from './schema.js';
+
+async function validateInput(input) {
+  const {
+    input: rawInput,
+    adminQueryPort,
+    fileQueryPort,
+    postQueryPort
+  } = input;
+  const validatedInput = postUpdateInputSchema().parse(rawInput);
+  const previousResult = await postQueryPort.findDetail({
+    id: validatedInput.id
+  });
+  if (!previousResult.post)
+    throw new PostNotFoundError();
+  const normalizeItems = (items) => normalizeStringSelection(items.map((item) => item.id)).map((id2) => ({
+    id: id2
+  }));
+  const { id, ...data } = validatedInput;
+  const preparedInput = {
+    id,
+    ...data,
+    parents: normalizeItems(data.parents),
+    tags: normalizeItems(data.tags),
+    relatedPosts: normalizeItems(data.relatedPosts),
+    contentImages: normalizeItems(data.contentImages),
+    files1: normalizeItems(data.files1),
+    files2: normalizeItems(data.files2)
+  };
+  await assertPostWriteRelationsExist({
+    relations: preparedInput,
+    adminQueryPort,
+    fileQueryPort,
+    postQueryPort
+  });
+  return { ...preparedInput, previous: previousResult.post };
+}
+
+export { validateInput };

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

@@ -0,0 +1,62 @@
+import { createCacheKey } from '../../../../../conventions/cache/cache-key.js';
+import { createResourceTag, createRelationTag } from '../../../../../conventions/cache/cache-tag.js';
+import { collectPostFileIds } from '../../../collect-post-file-ids.js';
+import { collectPostReferenceIds } from '../../../collect-post-reference-ids.js';
+
+const createPostFindDetailCacheKey = (input) => createCacheKey("post", "find-detail", {
+  id: input.id,
+  type: input.type,
+  slug: input.slug,
+  isActive: input.isActive,
+  topicSlug: input.topicSlug
+});
+function createPostListCardCacheTags(post) {
+  return [
+    createResourceTag("post", { id: post.id }),
+    ...post.topic ? [
+      createResourceTag("post", { id: post.topic.id }),
+      createRelationTag("post", "topic", { id: post.id })
+    ] : [],
+    ...post.coverImage ? [
+      createResourceTag("file", { id: post.coverImage.id }),
+      createRelationTag("post", "cover-image", { id: post.id })
+    ] : []
+  ].flat();
+}
+const createPostFindDetailCacheTags = (_, result) => {
+  const { post, previous, next } = result.data;
+  const postReferenceIds = collectPostReferenceIds(post);
+  const fileIds = collectPostFileIds(post);
+  return [
+    ...new Set(
+      [
+        // Adjacent cards can change whenever collection membership or order changes.
+        createResourceTag("post"),
+        createResourceTag("post", { id: post.id }),
+        ...post.author ? [
+          createResourceTag("admin", { id: post.author.id }),
+          createRelationTag("post", "author", { id: post.id })
+        ] : [],
+        ...postReferenceIds.flatMap((id) => [
+          createResourceTag("post", { id })
+        ]),
+        ...fileIds.map((id) => createResourceTag("file", { id })),
+        createRelationTag("post", "topic", { id: post.id }),
+        createRelationTag("post", "parent", { id: post.id }),
+        createRelationTag("post", "child", { id: post.id }),
+        createRelationTag("post", "tag", { id: post.id }),
+        createRelationTag("post", "tagged-post", { id: post.id }),
+        createRelationTag("post", "related-post", { id: post.id }),
+        createRelationTag("post", "referencing-post", { id: post.id }),
+        createRelationTag("post", "posts-in-topic", { id: post.id }),
+        createRelationTag("post", "cover-image", { id: post.id }),
+        createRelationTag("post", "content-image", { id: post.id }),
+        createRelationTag("post", "file", { id: post.id }),
+        ...previous ? createPostListCardCacheTags(previous) : [],
+        ...next ? createPostListCardCacheTags(next) : []
+      ].flat()
+    )
+  ];
+};
+
+export { createPostFindDetailCacheKey, createPostFindDetailCacheTags };

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

@@ -0,0 +1,34 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { PostNotFoundError } from '../../../errors/operation-errors.js';
+import { createPostFindDetailCacheTags, createPostFindDetailCacheKey } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+function createPostFindDetailQuery(input) {
+  const { authorization, postQueryPort } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "query",
+        cache: {
+          key: createPostFindDetailCacheKey,
+          tags: createPostFindDetailCacheTags
+        }
+      },
+      validate(input2) {
+        return validateInput(input2);
+      }
+    },
+    async (input2) => {
+      const { post, previous, next } = await postQueryPort.findDetail(input2);
+      if (!post) {
+        return operationResult.failure(new PostNotFoundError());
+      }
+      return operationResult.success({ post, previous, next });
+    }
+  );
+}
+
+export { createPostFindDetailQuery };

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

@@ -0,0 +1,24 @@
+import { POST_TYPES } from 'sitero-domain';
+import { z } from 'zod';
+import { slugSchema, idSchema } from '../../../../../../conventions/validation/schema.js';
+import { POST_FIELD_ERROR_CODES } from '../../../../errors/codes.js';
+
+const postFindDetailInputSchema = () => z.object({
+  id: idSchema().optional(),
+  type: z.enum(POST_TYPES).optional(),
+  slug: slugSchema().optional(),
+  isActive: z.boolean().optional(),
+  topicSlug: slugSchema().optional()
+}).superRefine((input, context) => {
+  const hasId = input.id !== void 0;
+  const hasTypeSlug = input.type !== void 0 && input.slug !== void 0;
+  if (hasId && (input.type !== void 0 || input.slug !== void 0) || !hasId && !hasTypeSlug) {
+    context.addIssue({
+      code: "custom",
+      message: POST_FIELD_ERROR_CODES.LOOKUP_INVALID,
+      path: ["id"]
+    });
+  }
+});
+
+export { postFindDetailInputSchema };

package/dist/src/application/resources/post/operations/queries/find-detail/validation/validate-input.js

@@ -0,0 +1,20 @@
+import { postFindDetailInputSchema } from './schema.js';
+
+function validateInput(input) {
+  const parsedInput = postFindDetailInputSchema().parse(input);
+  const { isActive, topicSlug } = parsedInput;
+  const scope = {
+    ...isActive !== void 0 ? { isActive } : {},
+    ...topicSlug !== void 0 ? { topicSlug } : {}
+  };
+  if (parsedInput.id !== void 0) {
+    return { id: parsedInput.id, ...scope };
+  }
+  return {
+    type: parsedInput.type,
+    slug: parsedInput.slug,
+    ...scope
+  };
+}
+
+export { validateInput };

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

@@ -0,0 +1,56 @@
+import { createCacheKey, normalizeSelection } from '../../../../../conventions/cache/cache-key.js';
+import { createResourceTag, createRelationTag } from '../../../../../conventions/cache/cache-tag.js';
+
+const createPostFindListCardsCacheKey = (input) => createCacheKey("post", "find-list-cards", {
+  locale: input.locale,
+  searchString: input.searchString,
+  type: input.type,
+  isActive: input.isActive,
+  isIndexActive: input.isIndexActive,
+  isSlugActive: input.isSlugActive,
+  isFeatured: input.isFeatured,
+  isShownOnHome: input.isShownOnHome,
+  state1: input.state1,
+  state2: input.state2,
+  state3: input.state3,
+  state4: input.state4,
+  state5: input.state5,
+  state6: input.state6,
+  state7: input.state7,
+  state8: input.state8,
+  state9: input.state9,
+  state10: input.state10,
+  topicId: input.topicId,
+  topicSlug: input.topicSlug,
+  parentId: input.parentId,
+  parentSlug: input.parentSlug,
+  postIds: normalizeSelection(input.postIds),
+  excludeIds: normalizeSelection(input.excludeIds),
+  page: input.page,
+  pageSize: input.pageSize
+});
+const createPostFindListCardsCacheTags = (input, result) => {
+  if (input.postIds?.length === 0) {
+    return [];
+  }
+  return [
+    ...new Set(
+      [
+        createResourceTag("post"),
+        ...result.data.items.flatMap((post) => [
+          createResourceTag("post", { id: post.id }),
+          ...post.topic ? [
+            createResourceTag("post", { id: post.topic.id }),
+            createRelationTag("post", "topic", { id: post.id })
+          ] : [],
+          ...post.coverImage ? [
+            createResourceTag("file", { id: post.coverImage.id }),
+            createRelationTag("post", "cover-image", { id: post.id })
+          ] : []
+        ])
+      ].flat()
+    )
+  ];
+};
+
+export { createPostFindListCardsCacheKey, createPostFindListCardsCacheTags };

package/dist/src/application/resources/post/operations/queries/find-list-cards/post-find-list-cards-query.js

@@ -0,0 +1,33 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { createPostFindListCardsCacheTags, createPostFindListCardsCacheKey } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+function createPostFindListCardsQuery(input) {
+  const { authorization, postQueryPort } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "query",
+        cache: {
+          key: createPostFindListCardsCacheKey,
+          tags: createPostFindListCardsCacheTags
+        }
+      },
+      validate(input2) {
+        return validateInput(input2);
+      }
+    },
+    async (input2) => {
+      if (input2.postIds?.length === 0) {
+        return operationResult.success({ items: [], total: 0 });
+      }
+      const { items, total } = await postQueryPort.findListCards(input2);
+      return operationResult.success({ items, total });
+    }
+  );
+}
+
+export { createPostFindListCardsQuery };