sitero 0.0.1

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

@@ -0,0 +1,47 @@
+import pLimit from 'p-limit';
+import { fileCreateManyValidator } from './file-create-many-validator.js';
+
+function createFileCreateManyAction(ctx) {
+  const {
+    coreServer: {
+      infrastructure: { repositories, zod },
+      interfaces: { executions, middlewares }
+    }
+  } = ctx;
+  return async function fileCreateManyAction({
+    formData
+  }) {
+    return executions.executeAction(
+      async () => {
+        await middlewares.admin.adminAuthMiddleware.authenticate();
+        const { uploadResults, folder } = await fileCreateManyValidator(
+          zod.schemas
+        ).parseAsync(formData);
+        const limit = pLimit(5);
+        await Promise.all(
+          uploadResults.map(
+            (file) => limit(async () => {
+              await repositories.fileCommandRepository.create({
+                key: file.key,
+                fileMeta: file.fileMeta,
+                checksum: file.checksum,
+                width: file.width,
+                height: file.height,
+                duration: file.duration,
+                ...folder !== void 0 ? { folder } : {},
+                translations: file.translations
+              });
+            })
+          )
+        );
+        return {
+          i18nKey: "ok.store-ok",
+          data: { count: uploadResults.length }
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createFileCreateManyAction };

package/dist/src/cms/server/interfaces/actions/resources/file/commands/create-many/file-create-many-validator.js

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

package/dist/src/cms/server/interfaces/actions/resources/file/commands/purge-many/file-purge-many-action.js

@@ -0,0 +1,49 @@
+import '../../../../../../../../core/domain/resources/admin/constants.js';
+import { isFileLocked } from '../../../../../../../../core/domain/resources/file/utils/is-file-locked.js';
+import { ServerError } from '../../../../../../../../core/server/server-error.js';
+import { filePurgeManyValidator } from './file-purge-many-validator.js';
+
+function createFilePurgeManyAction(ctx) {
+  const {
+    coreServer: {
+      infrastructure: { services, repositories, zod },
+      interfaces: { executions, middlewares }
+    }
+  } = ctx;
+  return async function filePurgeManyAction({
+    formData
+  }) {
+    return executions.executeAction(
+      async () => {
+        await middlewares.admin.adminAuthMiddleware.authenticate();
+        const { ids } = await filePurgeManyValidator(zod.schemas).parseAsync(
+          formData
+        );
+        const foundFiles = await repositories.fileQueryRepository.findManyByIds(
+          { ids }
+        );
+        if (foundFiles.length === 0) throw ServerError.notFound();
+        if (foundFiles.some((file) => isFileLocked(file))) {
+          throw new ServerError({ i18nKey: "error.files-destroy-is-locked" });
+        }
+        const keys = foundFiles.map((file) => file.key);
+        await Promise.all(
+          keys.map(
+            async (key) => await services.storageService.remove({ key })
+          )
+        );
+        await Promise.all(
+          foundFiles.map(
+            async (file) => await repositories.fileCommandRepository.delete({ id: file.id })
+          )
+        );
+        return {
+          i18nKey: "ok.destroy-ok"
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createFilePurgeManyAction };

package/dist/src/cms/server/interfaces/actions/resources/file/commands/purge-many/file-purge-many-validator.js

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

package/dist/src/cms/server/interfaces/actions/resources/file/commands/restore-many/file-create-restore-validator.js

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

package/dist/src/cms/server/interfaces/actions/resources/file/commands/restore-many/file-restore-many-action.js

@@ -0,0 +1,29 @@
+import { fileRestoreManyValidator } from './file-create-restore-validator.js';
+
+function createFileRestoreManyAction(ctx) {
+  const {
+    coreServer: {
+      infrastructure: { repositories, zod },
+      interfaces: { executions, middlewares }
+    }
+  } = ctx;
+  return async function fileRestoreManyAction({
+    formData
+  }) {
+    return executions.executeAction(
+      async () => {
+        await middlewares.admin.adminAuthMiddleware.authenticate();
+        const { ids } = await fileRestoreManyValidator(zod.schemas).parseAsync(
+          formData
+        );
+        await repositories.fileCommandRepository.restoreMany({ ids });
+        return {
+          i18nKey: "ok.restore-ok"
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createFileRestoreManyAction };

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

@@ -0,0 +1,33 @@
+import '../../../../../../../../core/domain/resources/admin/constants.js';
+import { isFileLocked } from '../../../../../../../../core/domain/resources/file/utils/is-file-locked.js';
+import { ServerError } from '../../../../../../../../core/server/server-error.js';
+
+function createFileSoftDeleteAction(ctx) {
+  const {
+    coreServer: {
+      infrastructure: { repositories },
+      interfaces: { executions, middlewares }
+    }
+  } = ctx;
+  return async function fileSoftDeleteAction({ id }) {
+    return executions.executeAction(
+      async () => {
+        await middlewares.admin.adminAuthMiddleware.authenticate();
+        const foundFile = await repositories.fileQueryRepository.findFull({
+          id
+        });
+        if (!foundFile) throw ServerError.notFound();
+        if (isFileLocked(foundFile)) {
+          throw new ServerError({ i18nKey: "error.files-destroy-is-locked" });
+        }
+        await repositories.fileCommandRepository.softDelete({ id });
+        return {
+          i18nKey: "ok.destroy-ok"
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createFileSoftDeleteAction };

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

@@ -0,0 +1,51 @@
+import '../../../../../../../../core/domain/resources/admin/constants.js';
+import { isFileLocked } from '../../../../../../../../core/domain/resources/file/utils/is-file-locked.js';
+import { ServerError } from '../../../../../../../../core/server/server-error.js';
+import { fileSoftDeleteManyValidator } from './file-soft-delete-many-validator.js';
+
+function createFileSoftDeleteManyAction(ctx) {
+  const {
+    coreServer: {
+      infrastructure: { repositories, zod },
+      interfaces: { executions, middlewares }
+    }
+  } = ctx;
+  return async function fileSoftDeleteManyAction({
+    formData
+  }) {
+    return executions.executeAction(
+      async () => {
+        await middlewares.admin.adminAuthMiddleware.authenticate();
+        const { ids } = await fileSoftDeleteManyValidator(
+          zod.schemas
+        ).parseAsync(formData);
+        const foundFiles = await repositories.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 repositories.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/cms/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/cms/server/interfaces/actions/resources/file/commands/update/file-update-action.js

@@ -0,0 +1,63 @@
+import path from 'node:path/posix';
+import { ServerError } from '../../../../../../../../core/server/server-error.js';
+import { fileUpdateValidator } from './file-update-validator.js';
+
+function createFileUpdateAction(ctx) {
+  const {
+    coreServer: {
+      infrastructure: { services, repositories, zod },
+      interfaces: { executions, middlewares }
+    }
+  } = ctx;
+  return async function fileUpdateAction({
+    id,
+    formData
+  }) {
+    return executions.executeAction(
+      async () => {
+        await middlewares.admin.adminAuthMiddleware.authenticate();
+        const { checksum, width, height, duration, translations } = await fileUpdateValidator(zod.schemas).parseAsync(formData);
+        const { folder, fileMeta, key: uploadedKey } = formData;
+        const foundFile = await repositories.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 services.storageService.move({
+            fromKey: oldKey,
+            toKey: newKey
+          });
+        }
+        const updatedFile = await repositories.fileCommandRepository.update({
+          file: foundFile,
+          id,
+          key: newKey,
+          checksum: checksum ?? foundFile.checksum,
+          fileMeta,
+          width,
+          height,
+          duration,
+          folder,
+          translations
+        });
+        if (uploadedKey) {
+          await services.storageService.remove({ key: oldKey });
+        }
+        return {
+          i18nKey: "ok.update-ok",
+          data: { file: updatedFile }
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createFileUpdateAction };

package/dist/src/cms/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.positiveInteger(),
+    name: schemas.text()
+  }),
+  // media info
+  width: schemas.positiveInteger().nullable(),
+  height: schemas.positiveInteger().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.text(),
+      // text
+      name: schemas.text().nullable(),
+      alt: schemas.text().nullable()
+    })
+  )
+});
+
+export { fileUpdateValidator };

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

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

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

@@ -0,0 +1,40 @@
+function createFileFindListCardsAction(ctx) {
+  const {
+    coreServer: {
+      infrastructure: { repositories },
+      interfaces: { executions, middlewares }
+    }
+  } = ctx;
+  return async function fileFindFullAction(params) {
+    return executions.executeAction(
+      async ({ locale }) => {
+        await middlewares.admin.adminAuthMiddleware.authenticate();
+        const { items, total } = await repositories.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
+        ],
+        isList: true
+      }
+    );
+  };
+}
+
+export { createFileFindListCardsAction };

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

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

package/dist/src/cms/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/cms/server/interfaces/actions/resources/folder/commands/delete/folder-delete-action.js

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

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

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

package/dist/src/cms/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/cms/server/interfaces/actions/resources/folder/queries/folder-find-full-action.js

@@ -0,0 +1,45 @@
+import '../../../../../../../core/domain/resources/admin/constants.js';
+import { ROOT_FOLDER_ID, ROOT_FOLDER } from '../../../../../../../core/domain/resources/constants.js';
+import { ServerError } from '../../../../../../../core/server/server-error.js';
+
+function createFolderFindFullAction(ctx) {
+  const {
+    coreServer: {
+      infrastructure: { repositories },
+      interfaces: { executions, middlewares }
+    }
+  } = ctx;
+  return async function folderFindFullAction(params) {
+    return executions.executeAction(
+      async (translator) => {
+        await middlewares.admin.adminAuthMiddleware.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 repositories.folderQueryRepository.findListCards({
+            parentFolderId: ROOT_FOLDER_ID
+          });
+          folder.subFolders = subFolders;
+          const { items: files } = await repositories.fileQueryRepository.findListCards({
+            locale: translator.locale,
+            folderId: ROOT_FOLDER_ID
+          });
+          folder.files = files;
+        } else {
+          const found = await repositories.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/cms/server/interfaces/actions/resources/folder/queries/folder-find-list-cards-action.js

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