sitero 0.1.6 → 0.2.0

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

@@ -0,0 +1,100 @@
+import { connectOrDisconnectOne, setMany } from '../helpers/relation-writes.js';
+import { CONFIG_DETAIL_INCLUDE } from './include.js';
+import { configDetailToDomain, configToDomain } from './mappers.js';
+
+const CONFIG_ORDER_BY = [
+  { index: "asc" },
+  { updatedAt: "desc" },
+  { createdAt: "desc" },
+  { id: "asc" }
+];
+function splitConfigUpdateData(config) {
+  const {
+    files1,
+    files2,
+    file1,
+    file2,
+    file3,
+    file4,
+    translations,
+    ...scalarValues
+  } = config;
+  const scalarUpdates = Object.fromEntries(
+    Object.entries(scalarValues).filter(([, value]) => value !== void 0)
+  );
+  return {
+    files1,
+    files2,
+    file1,
+    file2,
+    file3,
+    file4,
+    translations,
+    scalarUpdates
+  };
+}
+function createConfigPrismaPorts(prisma) {
+  return {
+    // ------------------------------------------------------------
+    // Command
+    // ------------------------------------------------------------
+    configCommandPort: {
+      async update({ id, config }) {
+        const {
+          files1,
+          files2,
+          file1,
+          file2,
+          file3,
+          file4,
+          translations,
+          scalarUpdates
+        } = splitConfigUpdateData(config);
+        const updated = await prisma.config.update({
+          where: { id },
+          data: {
+            ...scalarUpdates,
+            files1: setMany(files1),
+            files2: setMany(files2),
+            file1: connectOrDisconnectOne(file1),
+            file2: connectOrDisconnectOne(file2),
+            file3: connectOrDisconnectOne(file3),
+            file4: connectOrDisconnectOne(file4),
+            translations: {
+              upsert: translations.map((translation) => ({
+                where: {
+                  configId_locale: { configId: id, locale: translation.locale }
+                },
+                update: translation,
+                create: translation
+              }))
+            }
+          }
+        });
+        return configToDomain(updated);
+      }
+    },
+    // ------------------------------------------------------------
+    // Query
+    // ------------------------------------------------------------
+    configQueryPort: {
+      async findDetail(input) {
+        const config = await prisma.config.findUnique({
+          where: "id" in input ? { id: input.id } : { slug: input.slug },
+          include: CONFIG_DETAIL_INCLUDE
+        });
+        return config ? configDetailToDomain(config) : null;
+      },
+      async findMany(input) {
+        const configs = await prisma.config.findMany({
+          ...input?.slugs ? { where: { slug: { in: input.slugs } } } : {},
+          include: CONFIG_DETAIL_INCLUDE,
+          orderBy: CONFIG_ORDER_BY
+        });
+        return configs.map(configDetailToDomain);
+      }
+    }
+  };
+}
+
+export { createConfigPrismaPorts };

package/dist/src/core/infrastructure/prisma/config/include.js

@@ -0,0 +1,11 @@
+const CONFIG_DETAIL_INCLUDE = {
+  files1: { include: { translations: true } },
+  files2: { include: { translations: true } },
+  file1: { include: { translations: true } },
+  file2: { include: { translations: true } },
+  file3: { include: { translations: true } },
+  file4: { include: { translations: true } },
+  translations: true
+};
+
+export { CONFIG_DETAIL_INCLUDE };

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

@@ -0,0 +1,26 @@
+function normalizeDecimal(value) {
+  return value?.toNumber() ?? null;
+}
+function normalizeConfigDecimals(config) {
+  return {
+    ...config,
+    dec1: normalizeDecimal(config.dec1),
+    dec2: normalizeDecimal(config.dec2),
+    dec3: normalizeDecimal(config.dec3),
+    dec4: normalizeDecimal(config.dec4),
+    dec5: normalizeDecimal(config.dec5),
+    dec6: normalizeDecimal(config.dec6),
+    dec7: normalizeDecimal(config.dec7),
+    dec8: normalizeDecimal(config.dec8),
+    dec9: normalizeDecimal(config.dec9),
+    dec10: normalizeDecimal(config.dec10)
+  };
+}
+function configToDomain(config) {
+  return normalizeConfigDecimals(config);
+}
+function configDetailToDomain(config) {
+  return normalizeConfigDecimals(config);
+}
+
+export { configDetailToDomain, configToDomain };

package/dist/src/core/infrastructure/prisma/file/base-mappers.js

@@ -0,0 +1,8 @@
+function fileToDomain(file) {
+  return { ...file };
+}
+function fileToCard(file) {
+  return { ...fileToDomain(file), translations: file.translations };
+}
+
+export { fileToCard, fileToDomain };

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

@@ -0,0 +1,170 @@
+import { createSearchWhere } from '../helpers/search-where.js';
+import { fileToDomain } from './base-mappers.js';
+import { FILE_NOT_IN_USE_WHERE, FILE_USAGE_COUNT_SELECT, FILE_DETAIL_INCLUDE } from './include.js';
+import { fileDetailToDomain, toFileContentData } from './mappers.js';
+
+const SEARCH_ROOT_FIELDS = [
+  "originalName"
+];
+const SEARCH_TRANSLATION_FIELDS = [
+  "name",
+  "alt"
+];
+const FILE_ORDER_BY = [
+  { updatedAt: "desc" },
+  { createdAt: "desc" },
+  { id: "asc" }
+];
+function createFilePrismaPorts(prisma) {
+  return {
+    // ------------------------------------------------------------
+    // Command
+    // ------------------------------------------------------------
+    fileCommandPort: {
+      async create(input) {
+        const file = await prisma.file.create({
+          data: {
+            key: input.key,
+            ...toFileContentData(input),
+            translations: { create: input.translations }
+          }
+        });
+        return fileToDomain(file);
+      },
+      async update(input) {
+        const file = await prisma.file.update({
+          where: { id: input.id, deletedAt: null },
+          data: {
+            translations: {
+              upsert: input.translations.map((translation) => ({
+                where: {
+                  fileId_locale: {
+                    fileId: input.id,
+                    locale: translation.locale
+                  }
+                },
+                update: translation,
+                create: translation
+              }))
+            }
+          }
+        });
+        return fileToDomain(file);
+      },
+      async softDelete({ id }) {
+        const file = await prisma.file.update({
+          where: {
+            id,
+            deletedAt: null,
+            isLocked: false,
+            ...FILE_NOT_IN_USE_WHERE
+          },
+          data: { deletedAt: /* @__PURE__ */ new Date() }
+        });
+        return fileToDomain(file);
+      },
+      async restore({ id }) {
+        const file = await prisma.file.update({
+          where: { id, deletedAt: { not: null } },
+          data: { deletedAt: null }
+        });
+        return fileToDomain(file);
+      },
+      async purge({ id }) {
+        const file = await prisma.file.delete({
+          where: {
+            id,
+            deletedAt: { not: null },
+            isLocked: false,
+            ...FILE_NOT_IN_USE_WHERE
+          }
+        });
+        return fileToDomain(file);
+      }
+    },
+    // ------------------------------------------------------------
+    // Extra
+    // ------------------------------------------------------------
+    fileReplaceContentPort: {
+      async replaceContent(input) {
+        const file = await prisma.file.update({
+          where: {
+            id: input.id,
+            key: input.expectedKey,
+            deletedAt: null,
+            isLocked: false,
+            ...FILE_NOT_IN_USE_WHERE
+          },
+          data: { key: input.key, ...toFileContentData(input) }
+        });
+        return fileToDomain(file);
+      }
+    },
+    // ------------------------------------------------------------
+    // Query
+    // ------------------------------------------------------------
+    fileQueryPort: {
+      async find(input) {
+        const file = await prisma.file.findUnique({
+          where: "id" in input ? { id: input.id } : { key: input.key }
+        });
+        return file ? fileToDomain(file) : null;
+      },
+      async findDetail({ id }) {
+        const file = await prisma.file.findUnique({
+          where: { id },
+          include: FILE_DETAIL_INCLUDE
+        });
+        return file ? fileDetailToDomain(file) : null;
+      },
+      async findListCards(input) {
+        const where = {
+          deletedAt: input.isDeleted ? { not: null } : null,
+          ...createSearchWhere({
+            searchString: input.searchString,
+            rootFields: SEARCH_ROOT_FIELDS,
+            translation: {
+              locale: input.locale,
+              fields: SEARCH_TRANSLATION_FIELDS
+            }
+          }),
+          ...input.type ? { type: input.type } : {},
+          ...input.isLocked === null || input.isLocked === void 0 ? {} : { isLocked: input.isLocked },
+          ...input.isInUse === null || input.isInUse === void 0 ? {} : input.isInUse ? { NOT: FILE_NOT_IN_USE_WHERE } : FILE_NOT_IN_USE_WHERE,
+          ...input.fileIds ? { id: { in: input.fileIds } } : {}
+        };
+        const pagination = input.page && input.pageSize ? { skip: (input.page - 1) * input.pageSize, take: input.pageSize } : {};
+        const { items, total } = await prisma.$transaction(
+          async (transaction) => {
+            const [items2, total2] = await Promise.all([
+              transaction.file.findMany({
+                where,
+                include: {
+                  translations: true,
+                  _count: { select: FILE_USAGE_COUNT_SELECT }
+                },
+                orderBy: FILE_ORDER_BY,
+                ...pagination
+              }),
+              transaction.file.count({ where })
+            ]);
+            return { items: items2, total: total2 };
+          }
+        );
+        return {
+          items: items.map((file) => {
+            const { _count, translations, ...record } = file;
+            return {
+              ...fileToDomain(record),
+              isInUse: Object.values(_count).some((count) => count > 0),
+              translations
+            };
+          }),
+          total
+        };
+      }
+    }
+  };
+}
+
+export { createFilePrismaPorts };

package/dist/src/core/infrastructure/prisma/file/include.js

@@ -0,0 +1,58 @@
+const livePostReference = { deletedAt: null };
+const FILE_USAGE_INCLUDE = {
+  adminAsAvatarImage: true,
+  postsAsCoverImage: { where: livePostReference },
+  postsAsContentImage: { where: livePostReference },
+  postsAsFiles1: { where: livePostReference },
+  postsAsFiles2: { where: livePostReference },
+  postsAsFile1: { where: livePostReference },
+  postsAsFile2: { where: livePostReference },
+  postsAsFile3: { where: livePostReference },
+  postsAsFile4: { where: livePostReference },
+  configsAsFiles1: true,
+  configsAsFiles2: true,
+  configsAsFile1: true,
+  configsAsFile2: true,
+  configsAsFile3: true,
+  configsAsFile4: true
+};
+const FILE_USAGE_COUNT_SELECT = {
+  adminAsAvatarImage: true,
+  postsAsCoverImage: { where: livePostReference },
+  postsAsContentImage: { where: livePostReference },
+  postsAsFiles1: { where: livePostReference },
+  postsAsFiles2: { where: livePostReference },
+  postsAsFile1: { where: livePostReference },
+  postsAsFile2: { where: livePostReference },
+  postsAsFile3: { where: livePostReference },
+  postsAsFile4: { where: livePostReference },
+  configsAsFiles1: true,
+  configsAsFiles2: true,
+  configsAsFile1: true,
+  configsAsFile2: true,
+  configsAsFile3: true,
+  configsAsFile4: true
+};
+const FILE_NOT_IN_USE_WHERE = {
+  adminAsAvatarImage: { none: {} },
+  postsAsCoverImage: { none: livePostReference },
+  postsAsContentImage: { none: livePostReference },
+  postsAsFiles1: { none: livePostReference },
+  postsAsFiles2: { none: livePostReference },
+  postsAsFile1: { none: livePostReference },
+  postsAsFile2: { none: livePostReference },
+  postsAsFile3: { none: livePostReference },
+  postsAsFile4: { none: livePostReference },
+  configsAsFiles1: { none: {} },
+  configsAsFiles2: { none: {} },
+  configsAsFile1: { none: {} },
+  configsAsFile2: { none: {} },
+  configsAsFile3: { none: {} },
+  configsAsFile4: { none: {} }
+};
+const FILE_DETAIL_INCLUDE = {
+  ...FILE_USAGE_INCLUDE,
+  translations: true
+};
+
+export { FILE_DETAIL_INCLUDE, FILE_NOT_IN_USE_WHERE, FILE_USAGE_COUNT_SELECT, FILE_USAGE_INCLUDE };

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

@@ -0,0 +1,52 @@
+import { mimeToExtension } from '../../../../shared/blob-file/mime-to-extension.js';
+import { classifyFileType } from '../../../../shared/blob-file/classify-file-type.js';
+import 'react';
+import 'ua-parser-js';
+import '../../../../shared/client/react-query/client.js';
+import 'react/jsx-runtime';
+import '@tanstack/react-query';
+import 'clsx';
+import 'tailwind-merge';
+import 'zod';
+import { adminToSafe } from '../admin/base-mappers.js';
+import { configToDomain } from '../config/mappers.js';
+import { postToDomain } from '../post/base-mappers.js';
+import { fileToDomain } from './base-mappers.js';
+
+function toFileContentData(input) {
+  const extension = mimeToExtension(input.mimeType);
+  return {
+    originalName: input.originalName,
+    size: input.size,
+    mimeType: input.mimeType,
+    extension,
+    type: classifyFileType(input.mimeType, extension),
+    width: input.width,
+    height: input.height,
+    duration: input.duration
+  };
+}
+function fileDetailToDomain(file) {
+  return {
+    ...fileToDomain(file),
+    isInUse: file.adminAsAvatarImage.length > 0 || file.postsAsCoverImage.length > 0 || file.postsAsContentImage.length > 0 || file.postsAsFiles1.length > 0 || file.postsAsFiles2.length > 0 || file.postsAsFile1.length > 0 || file.postsAsFile2.length > 0 || file.postsAsFile3.length > 0 || file.postsAsFile4.length > 0 || file.configsAsFiles1.length > 0 || file.configsAsFiles2.length > 0 || file.configsAsFile1.length > 0 || file.configsAsFile2.length > 0 || file.configsAsFile3.length > 0 || file.configsAsFile4.length > 0,
+    translations: file.translations,
+    adminAsAvatarImage: file.adminAsAvatarImage.map(adminToSafe),
+    postsAsCoverImage: file.postsAsCoverImage.map(postToDomain),
+    postsAsContentImage: file.postsAsContentImage.map(postToDomain),
+    postsAsFiles1: file.postsAsFiles1.map(postToDomain),
+    postsAsFiles2: file.postsAsFiles2.map(postToDomain),
+    postsAsFile1: file.postsAsFile1.map(postToDomain),
+    postsAsFile2: file.postsAsFile2.map(postToDomain),
+    postsAsFile3: file.postsAsFile3.map(postToDomain),
+    postsAsFile4: file.postsAsFile4.map(postToDomain),
+    configsAsFiles1: file.configsAsFiles1.map(configToDomain),
+    configsAsFiles2: file.configsAsFiles2.map(configToDomain),
+    configsAsFile1: file.configsAsFile1.map(configToDomain),
+    configsAsFile2: file.configsAsFile2.map(configToDomain),
+    configsAsFile3: file.configsAsFile3.map(configToDomain),
+    configsAsFile4: file.configsAsFile4.map(configToDomain)
+  };
+}
+
+export { fileDetailToDomain, toFileContentData };

package/dist/src/core/infrastructure/prisma/helpers/relation-writes.js

@@ -0,0 +1,10 @@
+const connectOne = (item) => item ? { connect: { id: item.id } } : void 0;
+const connectOrDisconnectOne = (item) => item ? { connect: { id: item.id } } : { disconnect: true };
+const connectMany = (items) => ({
+  connect: items.map(({ id }) => ({ id }))
+});
+const setMany = (items) => ({
+  set: items.map(({ id }) => ({ id }))
+});
+
+export { connectMany, connectOne, connectOrDisconnectOne, setMany };

package/dist/src/core/infrastructure/prisma/helpers/search-where.js

@@ -0,0 +1,25 @@
+const containsConditions = (fields, value) => fields.map((field) => ({
+  [field]: { contains: value, mode: "insensitive" }
+}));
+function createSearchWhere({
+  searchString,
+  rootFields = [],
+  translation
+}) {
+  if (!searchString) return {};
+  const roots = containsConditions(rootFields, searchString);
+  const translations = translation?.fields.length ? [
+    {
+      translations: {
+        some: {
+          locale: translation.locale,
+          OR: containsConditions(translation.fields, searchString)
+        }
+      }
+    }
+  ] : [];
+  const OR = [...roots, ...translations];
+  return OR.length ? { OR } : {};
+}
+
+export { createSearchWhere };

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

@@ -0,0 +1,75 @@
+import { createSearchWhere } from '../helpers/search-where.js';
+import { inquiryToDomain } from './mappers.js';
+
+const SEARCH_ROOT_FIELDS = [
+  "text1",
+  "text2",
+  "text3",
+  "text4",
+  "text5",
+  "text6",
+  "text7",
+  "text8",
+  "text9",
+  "text10"
+];
+const INQUIRY_ORDER_BY = [
+  { createdAt: "desc" },
+  { id: "asc" }
+];
+function toInquiryCreateData(input) {
+  return Object.fromEntries(
+    Object.entries(input).filter(([, value]) => value !== void 0)
+  );
+}
+function createInquiryPrismaPorts(prisma) {
+  return {
+    // ------------------------------------------------------------
+    // Command
+    // ------------------------------------------------------------
+    inquiryCommandPort: {
+      async create(input) {
+        return inquiryToDomain(
+          await prisma.inquiry.create({ data: toInquiryCreateData(input) })
+        );
+      },
+      async delete({ id }) {
+        return inquiryToDomain(await prisma.inquiry.delete({ where: { id } }));
+      }
+    },
+    // ------------------------------------------------------------
+    // Query
+    // ------------------------------------------------------------
+    inquiryQueryPort: {
+      async find({ id }) {
+        const inquiry = await prisma.inquiry.findUnique({ where: { id } });
+        return inquiry ? inquiryToDomain(inquiry) : null;
+      },
+      async findListCards(input) {
+        const where = {
+          ...createSearchWhere({
+            searchString: input.searchString,
+            rootFields: SEARCH_ROOT_FIELDS
+          })
+        };
+        const pagination = input.page && input.pageSize ? { skip: (input.page - 1) * input.pageSize, take: input.pageSize } : {};
+        const { items, total } = await prisma.$transaction(
+          async (transaction) => {
+            const [items2, total2] = await Promise.all([
+              transaction.inquiry.findMany({
+                where,
+                orderBy: INQUIRY_ORDER_BY,
+                ...pagination
+              }),
+              transaction.inquiry.count({ where })
+            ]);
+            return { items: items2, total: total2 };
+          }
+        );
+        return { items: items.map(inquiryToDomain), total };
+      }
+    }
+  };
+}
+
+export { createInquiryPrismaPorts };

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

@@ -0,0 +1,19 @@
+function inquiryToDomain(inquiry) {
+  return {
+    id: inquiry.id,
+    text1: inquiry.text1,
+    text2: inquiry.text2,
+    text3: inquiry.text3,
+    text4: inquiry.text4,
+    text5: inquiry.text5,
+    text6: inquiry.text6,
+    text7: inquiry.text7,
+    text8: inquiry.text8,
+    text9: inquiry.text9,
+    text10: inquiry.text10,
+    createdAt: inquiry.createdAt,
+    updatedAt: inquiry.updatedAt
+  };
+}
+
+export { inquiryToDomain };

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

@@ -0,0 +1,11 @@
+function postToDomain(post) {
+  return {
+    ...post,
+    dec1: post.dec1?.toNumber() ?? null,
+    dec2: post.dec2?.toNumber() ?? null,
+    dec3: post.dec3?.toNumber() ?? null,
+    dec4: post.dec4?.toNumber() ?? null
+  };
+}
+
+export { postToDomain };

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

@@ -0,0 +1,34 @@
+const POST_REFERENCE_INCLUDE = {
+  translations: true
+};
+const POST_LIST_CARD_INCLUDE = {
+  translations: true,
+  topic: { include: POST_REFERENCE_INCLUDE },
+  coverImage: { include: { translations: true } }
+};
+const POST_DETAIL_INCLUDE = {
+  ...POST_LIST_CARD_INCLUDE,
+  author: {
+    include: {
+      translations: true,
+      avatarImage: { include: { translations: true } }
+    }
+  },
+  postsInTopic: { include: POST_REFERENCE_INCLUDE },
+  parents: { include: POST_REFERENCE_INCLUDE },
+  children: { include: POST_REFERENCE_INCLUDE },
+  tags: { include: POST_REFERENCE_INCLUDE },
+  taggedPosts: { include: POST_REFERENCE_INCLUDE },
+  relatedPosts: { include: POST_REFERENCE_INCLUDE },
+  referencingPosts: { include: POST_REFERENCE_INCLUDE },
+  contentImages: { include: { translations: true } },
+  files1: { include: { translations: true } },
+  files2: { include: { translations: true } },
+  file1: { include: { translations: true } },
+  file2: { include: { translations: true } },
+  file3: { include: { translations: true } },
+  file4: { include: { translations: true } },
+  seoMetadatas: true
+};
+
+export { POST_DETAIL_INCLUDE, POST_LIST_CARD_INCLUDE, POST_REFERENCE_INCLUDE };

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

@@ -0,0 +1,50 @@
+import { adminListCardToDomain } from '../admin/mappers.js';
+import { fileToCard } from '../file/base-mappers.js';
+import { seoMetadataToDomain } from '../seo-metadata/mappers.js';
+import { postToDomain } from './base-mappers.js';
+
+function translationToDomain(translation) {
+  return {
+    ...translation,
+    externalLinks: translation.externalLinks,
+    faq: translation.faq,
+    toc: translation.toc
+  };
+}
+function postReferenceToDomain(post) {
+  return {
+    ...postToDomain(post),
+    translations: post.translations.map(translationToDomain)
+  };
+}
+function postListCardToDomain(post) {
+  return {
+    ...postReferenceToDomain(post),
+    topic: post.topic ? postReferenceToDomain(post.topic) : null,
+    coverImage: post.coverImage ? fileToCard(post.coverImage) : null
+  };
+}
+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),
+    referencingPosts: post.referencingPosts.map(postReferenceToDomain),
+    contentImages: post.contentImages.map(fileToCard),
+    files1: post.files1.map(fileToCard),
+    files2: post.files2.map(fileToCard),
+    file1: post.file1 ? fileToCard(post.file1) : null,
+    file2: post.file2 ? fileToCard(post.file2) : null,
+    file3: post.file3 ? fileToCard(post.file3) : null,
+    file4: post.file4 ? fileToCard(post.file4) : null,
+    seoMetadatas: post.seoMetadatas.map(seoMetadataToDomain)
+  };
+}
+
+export { postDetailToDomain, postListCardToDomain, postReferenceToDomain };