@yimingliao/cms 0.0.126 → 0.0.127

package/dist/src/server/interfaces/actions/resources/file/commands/soft-delete-many/create-file-soft-delete-many-action.js

@@ -0,0 +1,47 @@
+import '../../../../../../../domain/resources/admin/constants.js';
+import { isFileLocked } from '../../../../../../../domain/resources/file/utils/is-file-locked.js';
+import { ServerError } from '../../../../../../server-error.js';
+import { fileSoftDeleteManyValidator } from './file-soft-delete-many-validator.js';
+
+function createFileSoftDeleteManyAction(ctx) {
+  const {
+    repositories: { fileQueryRepository, fileCommandRepository },
+    middlewares: { authMiddleware },
+    action: { executeAction },
+    schemas: { schemas }
+  } = ctx;
+  return async function fileSoftDeleteManyAction({
+    formData
+  }) {
+    return executeAction(
+      async () => {
+        await authMiddleware.authenticate();
+        const { ids } = await fileSoftDeleteManyValidator(schemas).parseAsync(formData);
+        const foundFiles = await fileQueryRepository.findManyByIds({ ids });
+        if (foundFiles.length === 0) throw ServerError.notFound();
+        const lockedFiles = [];
+        const targetIds = [];
+        for (const file of foundFiles) {
+          if (isFileLocked(file)) {
+            lockedFiles.push(file.id);
+          } else {
+            targetIds.push(file.id);
+          }
+        }
+        const hasLockedFile = lockedFiles.length > 0;
+        const count = await fileCommandRepository.softDeleteMany({
+          ids: targetIds
+        });
+        if (count === 0) {
+          throw new ServerError({ i18nKey: "error.files-batch-destroy-no" });
+        }
+        return {
+          i18nKey: hasLockedFile ? "ok.files-batch-destroy-has-locked" : "ok.destroy-ok"
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createFileSoftDeleteManyAction };

package/dist/src/server/interfaces/actions/resources/file/commands/soft-delete-many/file-soft-delete-many-validator.js

@@ -0,0 +1,5 @@
+const fileSoftDeleteManyValidator = (schemas) => schemas.z.object({
+  ids: schemas.array(schemas.id().exist({ table: "files", column: "id" }))
+});
+
+export { fileSoftDeleteManyValidator };

package/dist/src/server/interfaces/actions/resources/file/commands/update/create-file-update-action.js

@@ -0,0 +1,59 @@
+import path from 'node:path/posix';
+import { ServerError } from '../../../../../../server-error.js';
+import { fileUpdateValidator } from './file-update-validator.js';
+
+function createFileUpdateAction(ctx) {
+  const {
+    services: { storageService },
+    repositories: { fileQueryRepository, fileCommandRepository },
+    middlewares: { authMiddleware },
+    action: { executeAction },
+    schemas: { schemas }
+  } = ctx;
+  return async function fileUpdateAction({
+    id,
+    formData
+  }) {
+    return executeAction(
+      async () => {
+        await authMiddleware.authenticate();
+        const { checksum, width, height, duration, translations } = await fileUpdateValidator(schemas).parseAsync(formData);
+        const { folder, fileMeta, key: uploadedKey } = formData;
+        const foundFile = await fileQueryRepository.findFull({ id });
+        if (!foundFile) throw ServerError.notFound();
+        const oldKey = foundFile.key;
+        let newKey = oldKey;
+        const folderChanged = folder?.key !== foundFile.folder?.key;
+        if (uploadedKey) {
+          newKey = uploadedKey;
+        } else if (folderChanged) {
+          const folderKey = folder?.key ?? "";
+          newKey = path.join(folderKey, path.basename(oldKey));
+          await storageService.move({ fromKey: oldKey, toKey: newKey });
+        }
+        const updatedFile = await fileCommandRepository.update({
+          file: foundFile,
+          id,
+          key: newKey,
+          checksum: checksum ?? foundFile.checksum,
+          fileMeta,
+          width,
+          height,
+          duration,
+          folder,
+          translations
+        });
+        if (uploadedKey) {
+          await storageService.remove({ key: oldKey });
+        }
+        return {
+          i18nKey: "ok.update-ok",
+          data: { file: updatedFile }
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createFileUpdateAction };

package/dist/src/server/interfaces/actions/resources/file/commands/update/file-update-validator.js

@@ -0,0 +1,35 @@
+const fileUpdateValidator = (schemas) => schemas.z.object({
+  // core
+  key: schemas.key().optional(),
+  checksum: schemas.sha256Hash().optional(),
+  // file meta
+  fileMeta: schemas.z.object({
+    type: schemas.text(),
+    size: schemas.positiveNumber(),
+    name: schemas.text()
+  }),
+  // media info
+  width: schemas.positiveNumber().nullable(),
+  height: schemas.positiveNumber().nullable(),
+  duration: schemas.positiveNumber().nullable(),
+  // ----------------------------------------------------------------------------
+  // relations
+  // ----------------------------------------------------------------------------
+  folder: schemas.z.object({
+    id: schemas.id().exist({ table: "folders", column: "id" })
+  }).nullable().optional(),
+  // ----------------------------------------------------------------------------
+  // translation
+  // ----------------------------------------------------------------------------
+  translations: schemas.array(
+    schemas.z.object({
+      // core
+      locale: schemas.locale(),
+      // text
+      name: schemas.text().nullable(),
+      alt: schemas.text().nullable()
+    })
+  )
+});
+
+export { fileUpdateValidator };

package/dist/src/server/interfaces/actions/resources/file/querires/create-file-find-full-action.js

@@ -0,0 +1,25 @@
+import { ServerError } from '../../../../../server-error.js';
+
+function createFileFindFullAction(ctx) {
+  const {
+    repositories: { fileQueryRepository },
+    action: { executeAction }
+  } = ctx;
+  return async function FileFindFullAction(params) {
+    return executeAction(
+      async () => {
+        const file = await fileQueryRepository.findFull(params);
+        if (!file) throw ServerError.notFound();
+        return {
+          data: { file }
+        };
+      },
+      {
+        type: "query",
+        key: ["file", "findFullAction", params.id]
+      }
+    );
+  };
+}
+
+export { createFileFindFullAction };

package/dist/src/server/interfaces/actions/resources/file/querires/create-file-find-list-cards-action.js

@@ -0,0 +1,38 @@
+function createFileFindListCardsAction(ctx) {
+  const {
+    repositories: { fileQueryRepository },
+    middlewares: { authMiddleware },
+    action: { executeAction }
+  } = ctx;
+  return async function fileFindFullAction(params) {
+    return executeAction(
+      async ({ locale }) => {
+        await authMiddleware.authenticate();
+        const { items, total } = await fileQueryRepository.findListCards({
+          ...params,
+          locale
+        });
+        return {
+          data: { items, total }
+        };
+      },
+      {
+        type: "query",
+        key: [
+          "file",
+          "findListCardsAction",
+          params.searchString,
+          params.type,
+          params.isDeleted,
+          params.isLocked,
+          params.folderId,
+          ...params.fileIds ?? [],
+          params.page,
+          params.pageSize
+        ]
+      }
+    );
+  };
+}
+
+export { createFileFindListCardsAction };

package/dist/src/server/interfaces/actions/resources/folder/commands/create/create-folder-create-action.js

@@ -0,0 +1,40 @@
+import path from 'node:path/posix';
+import { folderCreateValidator } from './folder-create-validator.js';
+
+function createFolderCreateAction(ctx) {
+  const {
+    repositories: { folderCommandRepository },
+    middlewares: { authMiddleware },
+    action: { executeAction },
+    schemas: { schemas }
+  } = ctx;
+  return async function folderCreateAction({
+    formData
+  }) {
+    return executeAction(
+      async () => {
+        await authMiddleware.authenticate();
+        const combinedKey = path.join(
+          formData.parentFolder?.key ?? "",
+          formData.name
+        );
+        const { name } = await folderCreateValidator(schemas).parseAsync({
+          ...formData,
+          key: combinedKey
+        });
+        const createdFolder = await folderCommandRepository.create({
+          key: combinedKey,
+          name,
+          parentFolder: formData.parentFolder
+        });
+        return {
+          i18nKey: "ok.store-ok",
+          data: { folder: createdFolder }
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createFolderCreateAction };

package/dist/src/server/interfaces/actions/resources/folder/commands/create/folder-create-validator.js

@@ -0,0 +1,12 @@
+const folderCreateValidator = (schemas) => schemas.z.object({
+  // core
+  key: schemas.key().unique({ table: "folders", column: "key" }),
+  name: schemas.pathSegment(),
+  // ----------------------------------------------------------------------------
+  // relations
+  // ----------------------------------------------------------------------------
+  // Folder
+  parentFolder: schemas.z.object({ id: schemas.id().exist({ table: "folders", column: "id" }) }).nullable()
+});
+
+export { folderCreateValidator };

package/dist/src/server/interfaces/actions/resources/folder/commands/delete/create-folder-delete-action.js

@@ -0,0 +1,30 @@
+import '../../../../../../../domain/resources/admin/constants.js';
+import { isFolderLocked } from '../../../../../../../domain/resources/folder/utils/is-folder-locked.js';
+import { ServerError } from '../../../../../../server-error.js';
+
+function createFolderDeleteAction(ctx) {
+  const {
+    repositories: { folderQueryRepository, folderCommandRepository },
+    middlewares: { authMiddleware },
+    action: { executeAction }
+  } = ctx;
+  return async function folderDeleteAction({ id }) {
+    return executeAction(
+      async () => {
+        await authMiddleware.authenticate();
+        const foundFolder = await folderQueryRepository.findFull({ id });
+        if (!foundFolder) throw ServerError.notFound();
+        if (isFolderLocked(foundFolder)) {
+          throw ServerError.forbidden();
+        }
+        await folderCommandRepository.delete({ id });
+        return {
+          i18nKey: "ok.destroy-ok"
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createFolderDeleteAction };

package/dist/src/server/interfaces/actions/resources/folder/commands/update/create-folder-update-action.js

@@ -0,0 +1,42 @@
+import path from 'node:path/posix';
+import { folderUpdateValidator } from './folder-update-validator.js';
+
+function createFolderUpdateAction(ctx) {
+  const {
+    repositories: { folderCommandRepository },
+    middlewares: { authMiddleware },
+    action: { executeAction },
+    schemas: { schemas }
+  } = ctx;
+  return async function folderUpdateAction({
+    id,
+    formData
+  }) {
+    return executeAction(
+      async () => {
+        await authMiddleware.authenticate();
+        const combinedKey = path.join(
+          formData.parentFolder?.key ?? "",
+          formData.name
+        );
+        const { name } = await folderUpdateValidator(schemas, id).parseAsync({
+          ...formData,
+          key: combinedKey
+        });
+        const updateddFolder = await folderCommandRepository.update({
+          id,
+          key: combinedKey,
+          name,
+          parentFolder: formData.parentFolder
+        });
+        return {
+          i18nKey: "ok.update-ok",
+          data: { folder: updateddFolder }
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createFolderUpdateAction };

package/dist/src/server/interfaces/actions/resources/folder/commands/update/folder-update-validator.js

@@ -0,0 +1,16 @@
+const folderUpdateValidator = (schemas, id) => schemas.z.object({
+  // core
+  key: schemas.key().unique({
+    table: "folders",
+    column: "key",
+    excludeSelf: { name: "id", value: id }
+  }),
+  name: schemas.pathSegment(),
+  // ----------------------------------------------------------------------------
+  // relations
+  // ----------------------------------------------------------------------------
+  // Folder
+  parentFolder: schemas.z.object({ id: schemas.id().exist({ table: "folders", column: "id" }) }).nullable()
+});
+
+export { folderUpdateValidator };

package/dist/src/server/interfaces/actions/resources/folder/queries/create-folder-find-full-action.js

@@ -0,0 +1,44 @@
+import '../../../../../../domain/resources/admin/constants.js';
+import { ROOT_FOLDER_ID, ROOT_FOLDER } from '../../../../../../domain/resources/constants.js';
+import { ServerError } from '../../../../../server-error.js';
+
+function createFolderFindFullAction(ctx) {
+  const {
+    repositories: { folderQueryRepository, fileQueryRepository },
+    middlewares: { authMiddleware },
+    action: { executeAction }
+  } = ctx;
+  return async function folderFindFullAction(params) {
+    return executeAction(
+      async (translator) => {
+        await authMiddleware.authenticate();
+        const resolvedKey = params.key || ROOT_FOLDER_ID;
+        const identity = "id" in params ? params.id : resolvedKey;
+        const isAtRoot = identity === ROOT_FOLDER_ID;
+        let folder = ROOT_FOLDER;
+        if (isAtRoot) {
+          const { items: subFolders } = await folderQueryRepository.findListCards({
+            parentFolderId: ROOT_FOLDER_ID
+          });
+          folder.subFolders = subFolders;
+          const { items: files } = await fileQueryRepository.findListCards({
+            locale: translator.locale,
+            folderId: ROOT_FOLDER_ID
+          });
+          folder.files = files;
+        } else {
+          const found = await folderQueryRepository.findFull(params);
+          if (!found) throw ServerError.notFound();
+          folder = found;
+        }
+        return { data: { folder } };
+      },
+      {
+        type: "query",
+        key: ["file", "findFullAction", params.id, params.key]
+      }
+    );
+  };
+}
+
+export { createFolderFindFullAction };

package/dist/src/server/interfaces/actions/resources/folder/queries/create-folder-find-list-cards-action.js

@@ -0,0 +1,32 @@
+function createFolderFindListCardsAction(ctx) {
+  const {
+    repositories: { folderQueryRepository },
+    middlewares: { authMiddleware },
+    action: { executeAction }
+  } = ctx;
+  return async function folderFindFullAction(params) {
+    return executeAction(
+      async () => {
+        await authMiddleware.authenticate();
+        const { items, total } = await folderQueryRepository.findListCards(params);
+        return {
+          data: { items, total }
+        };
+      },
+      {
+        type: "query",
+        key: [
+          "folder",
+          "findListCardsAction",
+          params.searchString,
+          params.parentFolderId,
+          ...params.folderIds ?? [],
+          params.page,
+          params.pageSize
+        ]
+      }
+    );
+  };
+}
+
+export { createFolderFindListCardsAction };

package/dist/src/server/interfaces/actions/resources/post/commands/create/create-post-create-action.js

@@ -0,0 +1,33 @@
+import { postCreateValidator } from './post-create-validator.js';
+
+function createPostCreateAction(ctx) {
+  const {
+    repositories: { postCommandRepository },
+    middlewares: { authMiddleware },
+    action: { executeAction },
+    schemas: { schemas, tocItemSchema }
+  } = ctx;
+  return async function postCreateAction({
+    formData
+  }) {
+    return executeAction(
+      async () => {
+        await authMiddleware.authenticate();
+        const validatedPayload = await postCreateValidator({
+          schemas,
+          tocItemSchema,
+          type: formData.type,
+          topicId: formData.topicId
+        }).parseAsync(formData);
+        const created = await postCommandRepository.create(validatedPayload);
+        return {
+          i18nKey: "ok.store-ok",
+          data: { post: created }
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createPostCreateAction };

package/dist/src/server/interfaces/actions/resources/post/commands/create/post-create-validator.js

@@ -0,0 +1,147 @@
+const postCreateValidator = ({
+  type,
+  topicId,
+  schemas,
+  tocItemSchema
+}) => schemas.z.object({
+  type: schemas.text(),
+  // ----------------------------------------------------------------------------
+  // states
+  // ----------------------------------------------------------------------------
+  isLocked: schemas.z.boolean(),
+  isActive: schemas.z.boolean(),
+  isIndexActive: schemas.z.boolean(),
+  index: schemas.positiveNumber().nullable(),
+  isSlugActive: schemas.z.boolean(),
+  slug: schemas.slug().unique({
+    table: "posts",
+    column: "slug",
+    scope: [
+      { name: "type", value: type, cast: "PostType" },
+      ...topicId ? [{ name: "topic_id", value: topicId }] : []
+      // Use for: [post], [post:category]
+    ]
+  }).nullable(),
+  isFeatured: schemas.z.boolean(),
+  isShownOnHome: schemas.z.boolean(),
+  // ----------------------------------------------------------------------------
+  // relations
+  // ----------------------------------------------------------------------------
+  // Admin
+  author: schemas.singleItem({ table: "admins", column: "id" }).nullable(),
+  // Picked by modal
+  // Post
+  topicId: schemas.id().exist({ table: "posts", column: "id" }).nullable(),
+  parents: schemas.multiItems({ table: "posts", column: "id" }),
+  // Picked by modal
+  tags: schemas.multiItems({ table: "posts", column: "id" }),
+  // Picked by modal
+  relatedPosts: schemas.multiItems({ table: "posts", column: "id" }),
+  // Picked by modal
+  // File
+  coverImage: schemas.singleItem({ table: "files", column: "id" }),
+  // Picked by modal
+  contentImageIds: schemas.array(
+    schemas.id().exist({ table: "files", column: "id" })
+  ),
+  // -----------------------------------------------------------------------
+  // --- custom fields
+  // -----------------------------------------------------------------------
+  // states
+  state1: schemas.z.boolean(),
+  state2: schemas.z.boolean(),
+  state3: schemas.z.boolean(),
+  state4: schemas.z.boolean(),
+  state5: schemas.z.boolean(),
+  state6: schemas.z.boolean(),
+  state7: schemas.z.boolean(),
+  state8: schemas.z.boolean(),
+  state9: schemas.z.boolean(),
+  state10: schemas.z.boolean(),
+  // multi images
+  images1: schemas.multiItems({ table: "files", column: "id" }),
+  images2: schemas.multiItems({ table: "files", column: "id" }),
+  // single images
+  image1: schemas.singleItem({ table: "files", column: "id" }),
+  image2: schemas.singleItem({ table: "files", column: "id" }),
+  image3: schemas.singleItem({ table: "files", column: "id" }),
+  image4: schemas.singleItem({ table: "files", column: "id" }),
+  // text
+  text1: schemas.text().nullable(),
+  text2: schemas.text().nullable(),
+  text3: schemas.text().nullable(),
+  text4: schemas.text().nullable(),
+  text5: schemas.text().nullable(),
+  text6: schemas.text().nullable(),
+  text7: schemas.text().nullable(),
+  text8: schemas.text().nullable(),
+  text9: schemas.text().nullable(),
+  text10: schemas.text().nullable(),
+  // json array
+  data1: schemas.array(schemas.z.any()),
+  data2: schemas.array(schemas.z.any()),
+  data3: schemas.array(schemas.z.any()),
+  data4: schemas.array(schemas.z.any()),
+  // ----------------------------------------------------------------------------
+  // translation
+  // ----------------------------------------------------------------------------
+  translations: schemas.array(
+    schemas.z.object({
+      locale: schemas.locale(),
+      // text
+      title: schemas.text().nullable(),
+      subtitle: schemas.text().nullable(),
+      summary: schemas.text().nullable(),
+      description: schemas.text().nullable(),
+      content: schemas.text().nullable(),
+      // better seo
+      externalLinks: schemas.array(
+        schemas.z.object({
+          name: schemas.text(),
+          href: schemas.text()
+        })
+      ),
+      faq: schemas.array(
+        schemas.z.object({
+          question: schemas.text(),
+          answer: schemas.text()
+        })
+      ),
+      toc: schemas.array(tocItemSchema),
+      // extra
+      readTime: schemas.positiveNumber().nullable(),
+      wordCount: schemas.positiveNumber(),
+      // -------------------------------------------
+      // --- custom fields
+      // -------------------------------------------
+      // text
+      text1: schemas.text().nullable(),
+      text2: schemas.text().nullable(),
+      text3: schemas.text().nullable(),
+      text4: schemas.text().nullable(),
+      text5: schemas.text().nullable(),
+      text6: schemas.text().nullable(),
+      text7: schemas.text().nullable(),
+      text8: schemas.text().nullable(),
+      text9: schemas.text().nullable(),
+      text10: schemas.text().nullable(),
+      // json array
+      data1: schemas.array(schemas.z.any()),
+      data2: schemas.array(schemas.z.any()),
+      data3: schemas.array(schemas.z.any()),
+      data4: schemas.array(schemas.z.any())
+    })
+  )
+}).transform((obj) => ({
+  ...obj,
+  // states
+  index: obj.isIndexActive ? obj.index : null,
+  slug: obj.isSlugActive ? obj.slug : null,
+  // translation
+  translations: obj.translations.map((t) => ({
+    ...t,
+    readTime: t.readTime !== 0 ? t.readTime : null
+  }))
+}));
+
+export { postCreateValidator };

package/dist/src/server/interfaces/actions/resources/post/commands/delete/create-post-delete-action.js

@@ -0,0 +1,25 @@
+import { ServerError } from '../../../../../../server-error.js';
+
+function createPostDeleteAction(ctx) {
+  const {
+    repositories: { postQueryRepository, postCommandRepository },
+    middlewares: { authMiddleware },
+    action: { executeAction }
+  } = ctx;
+  return async function postDeleteAction({ id }) {
+    return executeAction(
+      async () => {
+        await authMiddleware.authenticate();
+        const post = await postQueryRepository.find({ id });
+        if (!post) throw ServerError.notFound();
+        await postCommandRepository.delete({ id: post.id });
+        return {
+          i18nKey: "ok.destroy-ok"
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createPostDeleteAction };

package/dist/src/server/interfaces/actions/resources/post/commands/update/create-post-update-action.js

@@ -0,0 +1,38 @@
+import { postUpdateValidator } from './post-update-validator.js';
+
+function createPostUpdateAction(ctx) {
+  const {
+    repositories: { postCommandRepository },
+    middlewares: { authMiddleware },
+    action: { executeAction },
+    schemas: { schemas, tocItemSchema }
+  } = ctx;
+  return async function postUpdateAction({
+    id,
+    formData
+  }) {
+    return executeAction(
+      async () => {
+        await authMiddleware.authenticate();
+        const validatedPayload = await postUpdateValidator({
+          id,
+          type: formData.type,
+          topicId: formData.topicId,
+          schemas,
+          tocItemSchema
+        }).parseAsync(formData);
+        const updatedPost = await postCommandRepository.update({
+          id,
+          ...validatedPayload
+        });
+        return {
+          i18nKey: "ok.update-ok",
+          data: { post: updatedPost }
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createPostUpdateAction };