sitero-server 0.0.1

package/dist/src/application/resources/file/operations/commands/restore-many/cache.js

@@ -0,0 +1,12 @@
+import { createResourceTag } from '../../../../../conventions/cache/cache-tag.js';
+
+const createFileRestoreManyInvalidationTags = (_, result) => {
+  const { restored } = result.data;
+  if (restored.length === 0) return [];
+  return [
+    createResourceTag("file"),
+    ...restored.map((file) => createResourceTag("file", { id: file.id }))
+  ].flat();
+};
+
+export { createFileRestoreManyInvalidationTags };

package/dist/src/application/resources/file/operations/commands/restore-many/file-restore-many-command.js

@@ -0,0 +1,80 @@
+import { FILE_ERROR_CODES } from '../../../errors/codes.js';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import pLimit from 'p-limit';
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { notifyObserverSafely } from '../../../../../../kernel/observer/notify-observer-safely.js';
+import { createFileRestoreManyInvalidationTags } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+const MAX_CONCURRENCY = 5;
+function createFileRestoreManyCommand(input) {
+  const { authorization, fileCommandPort, fileQueryPort, observer } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "command",
+        invalidate: { tags: createFileRestoreManyInvalidationTags }
+      },
+      async validate(input2) {
+        return validateInput(input2);
+      }
+    },
+    async (input2, context) => {
+      const limit = pLimit(MAX_CONCURRENCY);
+      const outcomes = await Promise.all(
+        input2.ids.map(
+          (id) => limit(async () => {
+            try {
+              const file = await fileQueryPort.findDetail({ id });
+              if (!file) {
+                return {
+                  status: "skipped",
+                  id,
+                  code: FILE_ERROR_CODES.NOT_FOUND
+                };
+              }
+              if (!file.deletedAt) {
+                return {
+                  status: "skipped",
+                  id,
+                  code: FILE_ERROR_CODES.RESTORE_NOT_DELETED
+                };
+              }
+              const restored = await fileCommandPort.restore({ id });
+              return { status: "restored", file: restored };
+            } catch (error) {
+              const failure = {
+                id,
+                code: "INTERNAL_ERROR"
+              };
+              await notifyObserverSafely(
+                observer,
+                (observer2) => observer2.onEffectError?.({
+                  context,
+                  effect: "persistence",
+                  error: { id, error }
+                })
+              );
+              return { status: "failed", failure };
+            }
+          })
+        )
+      );
+      return operationResult.success({
+        restored: outcomes.flatMap(
+          (outcome) => outcome.status === "restored" ? [outcome.file] : []
+        ),
+        skipped: outcomes.flatMap(
+          (outcome) => outcome.status === "skipped" ? [{ id: outcome.id, code: outcome.code }] : []
+        ),
+        failed: outcomes.flatMap(
+          (outcome) => outcome.status === "failed" ? [outcome.failure] : []
+        )
+      });
+    }
+  );
+}
+
+export { createFileRestoreManyCommand };

package/dist/src/application/resources/file/operations/commands/restore-many/validation/schema.js

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

package/dist/src/application/resources/file/operations/commands/restore-many/validation/validate-input.js

@@ -0,0 +1,8 @@
+import { fileRestoreManyInputSchema } from './schema.js';
+
+async function validateInput(input) {
+  const { ids } = await fileRestoreManyInputSchema().parseAsync(input);
+  return { ids: [...new Set(ids)] };
+}
+
+export { validateInput };

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

@@ -0,0 +1,11 @@
+import { createResourceTag } from '../../../../../conventions/cache/cache-tag.js';
+
+const createFileUpdateInvalidationTags = (_, result) => {
+  const { file } = result.data;
+  return [
+    createResourceTag("file"),
+    createResourceTag("file", { id: file.id })
+  ].flat();
+};
+
+export { createFileUpdateInvalidationTags };

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

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

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { addDuplicateLocaleIssues } from '../../../../../../conventions/validation/add-duplicate-locale-issues.js';
+import { textSchema, requiredTextSchema, idSchema } from '../../../../../../conventions/validation/schema.js';
+
+const fileUpdateInputSchema = () => z.object({
+  id: idSchema(),
+  translations: z.array(
+    z.object({
+      locale: requiredTextSchema(),
+      name: textSchema().nullable(),
+      alt: textSchema().nullable()
+    })
+  ).min(1).superRefine(addDuplicateLocaleIssues)
+});
+
+export { fileUpdateInputSchema };

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

@@ -0,0 +1,17 @@
+import { FileNotFoundError, FileUpdateDeletedError } from '../../../../errors/operation-errors.js';
+import { fileUpdateInputSchema } from './schema.js';
+
+async function validateInput(input) {
+  const { input: rawInput, fileQueryPort } = input;
+  const validatedInput = await fileUpdateInputSchema().parseAsync(rawInput);
+  const previous = await fileQueryPort.findDetail({ id: validatedInput.id });
+  if (!previous) {
+    throw new FileNotFoundError();
+  }
+  if (previous.deletedAt) {
+    throw new FileUpdateDeletedError();
+  }
+  return { ...validatedInput, previous };
+}
+
+export { validateInput };

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

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

package/dist/src/application/resources/file/operations/queries/find-detail/file-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 { FileNotFoundError } from '../../../errors/operation-errors.js';
+import { createFileFindDetailCacheTags, createFileFindDetailCacheKey } from './cache.js';
+import { fileFindDetailInputSchema } from './validation/schema.js';
+
+function createFileFindDetailQuery(input) {
+  const { authorization, fileQueryPort } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "query",
+        cache: {
+          key: createFileFindDetailCacheKey,
+          tags: createFileFindDetailCacheTags
+        }
+      },
+      validate(input2) {
+        return fileFindDetailInputSchema().parse(input2);
+      }
+    },
+    async (input2) => {
+      const file = await fileQueryPort.findDetail({ id: input2.id });
+      if (!file) {
+        return operationResult.failure(new FileNotFoundError());
+      }
+      return operationResult.success({ file });
+    }
+  );
+}
+
+export { createFileFindDetailQuery };

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

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

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

@@ -0,0 +1,26 @@
+import { createCacheKey, normalizeSelection } from '../../../../../conventions/cache/cache-key.js';
+import { createResourceTag } from '../../../../../conventions/cache/cache-tag.js';
+
+const createFileFindListCardsCacheKey = (input) => createCacheKey("file", "find-list-cards", {
+  locale: input.locale,
+  searchString: input.searchString,
+  type: input.type,
+  isDeleted: input.isDeleted,
+  isLocked: input.isLocked,
+  isInUse: input.isInUse,
+  fileIds: normalizeSelection(input.fileIds),
+  page: input.page,
+  pageSize: input.pageSize
+});
+const createFileFindListCardsCacheTags = (_, result) => [
+  ...new Set(
+    [
+      createResourceTag("file"),
+      ...result.data.items.map(
+        (file) => createResourceTag("file", { id: file.id })
+      )
+    ].flat()
+  )
+];
+
+export { createFileFindListCardsCacheKey, createFileFindListCardsCacheTags };

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

@@ -0,0 +1,30 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { createFileFindListCardsCacheTags, createFileFindListCardsCacheKey } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+function createFileFindListCardsQuery(input) {
+  const { authorization, fileQueryPort } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "query",
+        cache: {
+          key: createFileFindListCardsCacheKey,
+          tags: createFileFindListCardsCacheTags
+        }
+      },
+      validate(input2) {
+        return validateInput(input2);
+      }
+    },
+    async (input2) => {
+      const { items, total } = await fileQueryPort.findListCards(input2);
+      return operationResult.success({ items, total });
+    }
+  );
+}
+
+export { createFileFindListCardsQuery };

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

@@ -0,0 +1,17 @@
+import { FILE_TYPES } from 'sitero-domain';
+import { z } from 'zod';
+import { idSchema, textSchema, requiredTextSchema } from '../../../../../../conventions/validation/schema.js';
+
+const fileFindListCardsInputSchema = () => z.object({
+  locale: requiredTextSchema(),
+  searchString: textSchema().optional(),
+  type: z.enum(FILE_TYPES).nullable().optional(),
+  isDeleted: z.boolean().optional(),
+  isLocked: z.boolean().nullable().optional(),
+  isInUse: z.boolean().nullable().optional(),
+  fileIds: z.array(idSchema()).optional(),
+  page: z.number().int().positive().optional(),
+  pageSize: z.number().int().positive().optional()
+});
+
+export { fileFindListCardsInputSchema };

package/dist/src/application/resources/file/operations/queries/find-list-cards/validation/validate-input.js

@@ -0,0 +1,11 @@
+import { fileFindListCardsInputSchema } from './schema.js';
+
+function validateInput(input) {
+  const validatedInput = fileFindListCardsInputSchema().parse(input);
+  return {
+    ...validatedInput,
+    isDeleted: validatedInput.isDeleted ?? false
+  };
+}
+
+export { validateInput };

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

@@ -0,0 +1,5 @@
+const INQUIRY_ERROR_CODES = {
+  NOT_FOUND: "INQUIRY_NOT_FOUND"
+};
+
+export { INQUIRY_ERROR_CODES };

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

@@ -0,0 +1,11 @@
+import { OperationError } from '../../../../contracts/operation/error.js';
+import { INQUIRY_ERROR_CODES } from './codes.js';
+
+class InquiryNotFoundError extends OperationError {
+  constructor() {
+    super({ code: INQUIRY_ERROR_CODES.NOT_FOUND });
+    this.name = "InquiryNotFoundError";
+  }
+}
+
+export { InquiryNotFoundError };

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

@@ -0,0 +1,8 @@
+import { createResourceTag } from '../../../../../conventions/cache/cache-tag.js';
+
+const createInquiryDeleteInvalidationTags = (_, result) => [
+  createResourceTag("inquiry"),
+  createResourceTag("inquiry", { id: result.data.inquiry.id })
+].flat();
+
+export { createInquiryDeleteInvalidationTags };

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

@@ -0,0 +1,33 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { InquiryNotFoundError } from '../../../errors/operation-errors.js';
+import { createInquiryDeleteInvalidationTags } from './cache.js';
+import { inquiryDeleteInputSchema } from './validation/schema.js';
+
+function createInquiryDeleteCommand(input) {
+  const { authorization, inquiryCommandPort, inquiryQueryPort } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "command",
+        invalidate: { tags: createInquiryDeleteInvalidationTags }
+      },
+      async validate(input2) {
+        const validatedInput = inquiryDeleteInputSchema().parse(input2);
+        const inquiry = await inquiryQueryPort.find(validatedInput);
+        if (!inquiry) {
+          throw new InquiryNotFoundError();
+        }
+        return validatedInput;
+      }
+    },
+    async (input2) => {
+      const inquiry = await inquiryCommandPort.delete(input2);
+      return operationResult.success({ inquiry });
+    }
+  );
+}
+
+export { createInquiryDeleteCommand };

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

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

package/dist/src/application/resources/inquiry/operations/queries/find/cache.js

@@ -0,0 +1,7 @@
+import { createCacheKey } from '../../../../../conventions/cache/cache-key.js';
+import { createResourceTag } from '../../../../../conventions/cache/cache-tag.js';
+
+const createInquiryFindCacheKey = (input) => createCacheKey("inquiry", "find", { id: input.id });
+const createInquiryFindCacheTags = (_, result) => [createResourceTag("inquiry", { id: result.data.inquiry.id })].flat();
+
+export { createInquiryFindCacheKey, createInquiryFindCacheTags };

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

@@ -0,0 +1,36 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { InquiryNotFoundError } from '../../../errors/operation-errors.js';
+import { createInquiryFindCacheTags, createInquiryFindCacheKey } from './cache.js';
+import { inquiryFindInputSchema } from './validation/schema.js';
+
+function createInquiryFindQuery(input) {
+  const { authorization, inquiryQueryPort } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "query",
+        cache: {
+          key: createInquiryFindCacheKey,
+          tags: createInquiryFindCacheTags
+        }
+      },
+      validate(input2) {
+        return inquiryFindInputSchema().parse(input2);
+      }
+    },
+    async (input2) => {
+      const inquiry = await inquiryQueryPort.find(input2);
+      if (!inquiry) {
+        return operationResult.failure(
+          new InquiryNotFoundError()
+        );
+      }
+      return operationResult.success({ inquiry });
+    }
+  );
+}
+
+export { createInquiryFindQuery };

package/dist/src/application/resources/inquiry/operations/queries/find/validation/schema.js

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

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

@@ -0,0 +1,16 @@
+import { createCacheKey } from '../../../../../conventions/cache/cache-key.js';
+import { createResourceTag } from '../../../../../conventions/cache/cache-tag.js';
+
+const createInquiryFindListCardsCacheKey = (input) => createCacheKey("inquiry", "find-list-cards", {
+  searchString: input.searchString,
+  page: input.page,
+  pageSize: input.pageSize
+});
+const createInquiryFindListCardsCacheTags = (_, result) => [
+  createResourceTag("inquiry"),
+  ...result.data.items.map(
+    (inquiry) => createResourceTag("inquiry", { id: inquiry.id })
+  )
+].flat();
+
+export { createInquiryFindListCardsCacheKey, createInquiryFindListCardsCacheTags };

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

@@ -0,0 +1,30 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { createInquiryFindListCardsCacheTags, createInquiryFindListCardsCacheKey } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+function createInquiryFindListCardsQuery(input) {
+  const { authorization, inquiryQueryPort } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "query",
+        cache: {
+          key: createInquiryFindListCardsCacheKey,
+          tags: createInquiryFindListCardsCacheTags
+        }
+      },
+      validate(input2) {
+        return validateInput(input2);
+      }
+    },
+    async (input2) => {
+      const { items, total } = await inquiryQueryPort.findListCards(input2);
+      return operationResult.success({ items, total });
+    }
+  );
+}
+
+export { createInquiryFindListCardsQuery };

package/dist/src/application/resources/inquiry/operations/queries/find-list-cards/validation/schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { textSchema } from '../../../../../../conventions/validation/schema.js';
+
+const inquiryFindListCardsInputSchema = () => z.object({
+  searchString: textSchema().optional(),
+  page: z.number().int().positive().optional(),
+  pageSize: z.number().int().positive().max(100).optional()
+});
+
+export { inquiryFindListCardsInputSchema };

package/dist/src/application/resources/inquiry/operations/queries/find-list-cards/validation/validate-input.js

@@ -0,0 +1,7 @@
+import { inquiryFindListCardsInputSchema } from './schema.js';
+
+async function validateInput(input) {
+  return inquiryFindListCardsInputSchema().parseAsync(input);
+}
+
+export { validateInput };

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

@@ -0,0 +1,51 @@
+import { AdminNotFoundError } from '../admin/errors/operation-errors.js';
+import 'sitero-domain';
+import 'zod';
+import { FileNotFoundError } from '../file/errors/operation-errors.js';
+import 'p-limit';
+import { PostNotFoundError } from './errors/operation-errors.js';
+
+async function assertPostWriteRelationsExist(input) {
+  const { relations, adminQueryPort, fileQueryPort, postQueryPort } = input;
+  if (relations.author) {
+    const admin = await adminQueryPort.find({ id: relations.author.id });
+    if (!admin) {
+      throw new AdminNotFoundError();
+    }
+  }
+  const fileIds = [
+    relations.coverImage?.id,
+    ...relations.contentImages.map((item) => item.id),
+    ...relations.files1.map((item) => item.id),
+    ...relations.files2.map((item) => item.id),
+    relations.file1?.id,
+    relations.file2?.id,
+    relations.file3?.id,
+    relations.file4?.id
+  ].filter((id) => id !== void 0);
+  await Promise.all(
+    [...new Set(fileIds)].map(async (id) => {
+      const file = await fileQueryPort.find({ id });
+      if (!file) {
+        throw new FileNotFoundError();
+      }
+    })
+  );
+  const postIds = [
+    relations.topic?.id,
+    ...relations.parents.map((item) => item.id),
+    ...relations.tags.map((item) => item.id),
+    ...relations.relatedPosts.map((item) => item.id)
+  ].filter((id) => id !== void 0);
+  if (!postIds.length) {
+    return;
+  }
+  const posts = await postQueryPort.findMany({ postIds });
+  const foundIds = new Set(posts.map((post) => post.id));
+  const missingId = postIds.find((id) => !foundIds.has(id));
+  if (missingId) {
+    throw new PostNotFoundError();
+  }
+}
+
+export { assertPostWriteRelationsExist };

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

@@ -0,0 +1,14 @@
+function collectPostFileIds(post) {
+  return [
+    post.coverImage?.id,
+    ...post.contentImages.map((file) => file.id),
+    ...post.files1.map((file) => file.id),
+    ...post.files2.map((file) => file.id),
+    post.file1?.id,
+    post.file2?.id,
+    post.file3?.id,
+    post.file4?.id
+  ].filter((id) => Boolean(id));
+}
+
+export { collectPostFileIds };

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

@@ -0,0 +1,14 @@
+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)
+  ].filter((id) => Boolean(id));
+}
+
+export { collectPostReferenceIds };

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

@@ -0,0 +1,9 @@
+const POST_ERROR_CODES = {
+  NOT_FOUND: "POST_NOT_FOUND",
+  DELETE_LOCKED: "POST_DELETE_LOCKED"
+};
+const POST_FIELD_ERROR_CODES = {
+  LOOKUP_INVALID: "validation.post.lookup.invalid"
+};
+
+export { POST_ERROR_CODES, POST_FIELD_ERROR_CODES };

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

@@ -0,0 +1,17 @@
+import { OperationError } from '../../../../contracts/operation/error.js';
+import { POST_ERROR_CODES } from './codes.js';
+
+class PostNotFoundError extends OperationError {
+  constructor() {
+    super({ code: POST_ERROR_CODES.NOT_FOUND });
+    this.name = "PostNotFoundError";
+  }
+}
+class PostDeleteLockedError extends OperationError {
+  constructor() {
+    super({ code: POST_ERROR_CODES.DELETE_LOCKED });
+    this.name = "PostDeleteLockedError";
+  }
+}
+
+export { PostDeleteLockedError, PostNotFoundError };