sitero 0.3.0 → 0.5.0

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

@@ -1,4 +1,5 @@
 import { ADMIN_ROLES } from 'sitero-domain';
+import { withActiveFileReferences } from '../helpers/active-file-references.js';
 import { connectOrDisconnectOne, connectOne } from '../helpers/relation-writes.js';
 import { createSearchWhere } from '../helpers/search-where.js';
 import { adminToSafe } from './base-mappers.js';
@@ -30,37 +31,52 @@ function createAdminPrismaPorts(prisma) {
     // ------------------------------------------------------------
     adminCommandPort: {
       async create(input) {
-        const { avatarImage, translations, ...data } = input;
-        const avatarImageWrite = connectOne(avatarImage);
-        return adminToSafe(
-          await prisma.admin.create({
-            data: {
-              ...data,
-              ...avatarImageWrite ? { avatarImage: avatarImageWrite } : {},
-              translations: { create: translations }
-            }
-          })
+        return withActiveFileReferences(
+          prisma,
+          [input.avatarImage],
+          async (transaction) => {
+            const { avatarImage, translations, ...data } = input;
+            const avatarImageWrite = connectOne(avatarImage);
+            return adminToSafe(
+              await transaction.admin.create({
+                data: {
+                  ...data,
+                  ...avatarImageWrite ? { avatarImage: avatarImageWrite } : {},
+                  translations: { create: translations }
+                }
+              })
+            );
+          }
         );
       },
       async update(input) {
-        const { id, avatarImage, translations, ...data } = input;
-        return adminToSafe(
-          await prisma.admin.update({
-            where: { id },
-            data: {
-              ...data,
-              avatarImage: connectOrDisconnectOne(avatarImage),
-              translations: {
-                upsert: translations.map((translation) => ({
-                  where: {
-                    adminId_locale: { adminId: id, locale: translation.locale }
-                  },
-                  update: translation,
-                  create: translation
-                }))
-              }
-            }
-          })
+        return withActiveFileReferences(
+          prisma,
+          [input.avatarImage],
+          async (transaction) => {
+            const { id, avatarImage, translations, ...data } = input;
+            return adminToSafe(
+              await transaction.admin.update({
+                where: { id },
+                data: {
+                  ...data,
+                  avatarImage: connectOrDisconnectOne(avatarImage),
+                  translations: {
+                    upsert: translations.map((translation) => ({
+                      where: {
+                        adminId_locale: {
+                          adminId: id,
+                          locale: translation.locale
+                        }
+                      },
+                      update: translation,
+                      create: translation
+                    }))
+                  }
+                }
+              })
+            );
+          }
         );
       },
       async delete({ id }) {

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

@@ -1,3 +1,4 @@
+import { withActiveFileReferences } from '../helpers/active-file-references.js';
 import { connectOrDisconnectOne, setMany } from '../helpers/relation-writes.js';
 import { CONFIG_DETAIL_INCLUDE } from './include.js';
 import { configDetailToDomain, configToDomain } from './mappers.js';
@@ -40,38 +41,54 @@ function createConfigPrismaPorts(prisma) {
     // ------------------------------------------------------------
     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 withActiveFileReferences(
+          prisma,
+          [
+            ...config.files1 ?? [],
+            ...config.files2 ?? [],
+            config.file1,
+            config.file2,
+            config.file3,
+            config.file4
+          ],
+          async (transaction) => {
+            const {
+              files1,
+              files2,
+              file1,
+              file2,
+              file3,
+              file4,
+              translations,
+              scalarUpdates
+            } = splitConfigUpdateData(config);
+            const updated = await transaction.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);
           }
-        });
-        return configToDomain(updated);
+        );
       }
     },
     // ------------------------------------------------------------

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

@@ -52,52 +52,97 @@ function createFilePrismaPorts(prisma) {
         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 prisma.$transaction(async (transaction) => {
+          await transaction.$queryRaw`SELECT id FROM files WHERE id = ${id} FOR UPDATE`;
+          const file = await transaction.file.update({
+            where: {
+              id,
+              deletedAt: null,
+              isLocked: false,
+              ...FILE_NOT_IN_USE_WHERE
+            },
+            data: { deletedAt: /* @__PURE__ */ new Date() }
+          });
+          return fileToDomain(file);
         });
-        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 prisma.$transaction(async (transaction) => {
+          await transaction.$queryRaw`SELECT id FROM files WHERE id = ${id} FOR UPDATE`;
+          const file = await transaction.file.findUnique({ where: { id } });
+          if (!file) return { status: "not-found" };
+          if (file.purgeStartedAt) return { status: "purge-started" };
+          if (!file.deletedAt) return { status: "not-deleted" };
+          const restored = await transaction.file.update({
+            where: { id },
+            data: { deletedAt: null }
+          });
+          return { status: "restored", file: fileToDomain(restored) };
         });
-        return fileToDomain(file);
       }
     },
     // ------------------------------------------------------------
     // Extra
     // ------------------------------------------------------------
+    filePurgePort: {
+      async prepare({ id }) {
+        return prisma.$transaction(async (transaction) => {
+          await transaction.$queryRaw`SELECT id FROM files WHERE id = ${id} FOR UPDATE NOWAIT`;
+          const file = await transaction.file.findFirstOrThrow({
+            where: {
+              id,
+              deletedAt: { not: null },
+              isLocked: false,
+              ...FILE_NOT_IN_USE_WHERE
+            }
+          });
+          if (file.purgeStartedAt) return fileToDomain(file);
+          return fileToDomain(
+            await transaction.file.update({
+              where: { id },
+              data: { purgeStartedAt: /* @__PURE__ */ new Date() }
+            })
+          );
+        });
+      },
+      async complete({ id }, removeObject) {
+        return prisma.$transaction(
+          async (transaction) => {
+            await transaction.$queryRaw`SELECT id FROM files WHERE id = ${id} FOR UPDATE NOWAIT`;
+            const file = await transaction.file.findFirstOrThrow({
+              where: {
+                id,
+                deletedAt: { not: null },
+                purgeStartedAt: { not: null },
+                isLocked: false,
+                ...FILE_NOT_IN_USE_WHERE
+              }
+            });
+            await removeObject({ key: file.key });
+            return fileToDomain(
+              await transaction.file.delete({ where: { id } })
+            );
+          },
+          { timeout: 3e4 }
+        );
+      }
+    },
     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 prisma.$transaction(async (transaction) => {
+          await transaction.$queryRaw`SELECT id FROM files WHERE id = ${input.id} FOR UPDATE`;
+          const file = await transaction.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);
         });
-        return fileToDomain(file);
       }
     },
     // ------------------------------------------------------------

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

@@ -1,14 +1,13 @@
-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 },
+  postsAsCoverImage: true,
+  postsAsContentImage: true,
+  postsAsFiles1: true,
+  postsAsFiles2: true,
+  postsAsFile1: true,
+  postsAsFile2: true,
+  postsAsFile3: true,
+  postsAsFile4: true,
   configsAsFiles1: true,
   configsAsFiles2: true,
   configsAsFile1: true,
@@ -18,14 +17,14 @@ const FILE_USAGE_INCLUDE = {
 };
 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 },
+  postsAsCoverImage: true,
+  postsAsContentImage: true,
+  postsAsFiles1: true,
+  postsAsFiles2: true,
+  postsAsFile1: true,
+  postsAsFile2: true,
+  postsAsFile3: true,
+  postsAsFile4: true,
   configsAsFiles1: true,
   configsAsFiles2: true,
   configsAsFile1: true,
@@ -35,14 +34,14 @@ const FILE_USAGE_COUNT_SELECT = {
 };
 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 },
+  postsAsCoverImage: { none: {} },
+  postsAsContentImage: { none: {} },
+  postsAsFiles1: { none: {} },
+  postsAsFiles2: { none: {} },
+  postsAsFile1: { none: {} },
+  postsAsFile2: { none: {} },
+  postsAsFile3: { none: {} },
+  postsAsFile4: { none: {} },
   configsAsFiles1: { none: {} },
   configsAsFiles2: { none: {} },
   configsAsFile1: { none: {} },
@@ -56,14 +55,14 @@ const FILE_DETAIL_INCLUDE = {
 };
 const FILE_RELATIONS_INCLUDE = {
   adminAsAvatarImage: { select: { id: true } },
-  postsAsCoverImage: { where: livePostReference, select: { id: true } },
-  postsAsContentImage: { where: livePostReference, select: { id: true } },
-  postsAsFiles1: { where: livePostReference, select: { id: true } },
-  postsAsFiles2: { where: livePostReference, select: { id: true } },
-  postsAsFile1: { where: livePostReference, select: { id: true } },
-  postsAsFile2: { where: livePostReference, select: { id: true } },
-  postsAsFile3: { where: livePostReference, select: { id: true } },
-  postsAsFile4: { where: livePostReference, select: { id: true } },
+  postsAsCoverImage: { select: { id: true } },
+  postsAsContentImage: { select: { id: true } },
+  postsAsFiles1: { select: { id: true } },
+  postsAsFiles2: { select: { id: true } },
+  postsAsFile1: { select: { id: true } },
+  postsAsFile2: { select: { id: true } },
+  postsAsFile3: { select: { id: true } },
+  postsAsFile4: { select: { id: true } },
   configsAsFiles1: { select: { slug: true } },
   configsAsFiles2: { select: { slug: true } },
   configsAsFile1: { select: { slug: true } },

package/dist/src/core/infrastructure/prisma/helpers/active-file-references.js

@@ -0,0 +1,20 @@
+import { FileNotFoundError } from 'sitero-server';
+
+async function withActiveFileReferences(prisma, items, write) {
+  return prisma.$transaction(async (transaction) => {
+    const ids = [
+      ...new Set(items.flatMap((item) => item ? [item.id] : []))
+    ].sort();
+    for (const id of ids) {
+      const rows = await transaction.$queryRaw`
+        SELECT deleted_at, purge_started_at FROM files WHERE id = ${id} FOR UPDATE
+      `;
+      const file = rows[0];
+      if (!file || file.deleted_at || file.purge_started_at)
+        throw new FileNotFoundError();
+    }
+    return write(transaction);
+  });
+}
+
+export { withActiveFileReferences };

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

@@ -1,4 +1,5 @@
 import { ulid } from 'ulid';
+import { withActiveFileReferences } from '../helpers/active-file-references.js';
 import { connectOrDisconnectOne, setMany, connectOne, connectMany } from '../helpers/relation-writes.js';
 import { createSearchWhere } from '../helpers/search-where.js';
 import { postToDomain } from './base-mappers.js';
@@ -54,105 +55,135 @@ function createPostPrismaPorts(prisma) {
     // ------------------------------------------------------------
     postCommandPort: {
       async create(input) {
-        const id = ulid();
-        const {
-          author,
-          topic,
-          parents,
-          tags,
-          relatedPosts,
-          coverImage,
-          contentImages,
-          files1,
-          files2,
-          file1,
-          file2,
-          file3,
-          file4,
-          translations,
-          slug,
-          ...scalars
-        } = input;
-        const authorWrite = connectOne(author);
-        const topicWrite = connectOne(topic);
-        const coverImageWrite = connectOne(coverImage);
-        const file1Write = connectOne(file1);
-        const file2Write = connectOne(file2);
-        const file3Write = connectOne(file3);
-        const file4Write = connectOne(file4);
-        const post = await prisma.post.create({
-          data: {
-            ...scalars,
-            id,
-            slug: slug?.trim() || id,
-            ...authorWrite ? { author: authorWrite } : {},
-            ...topicWrite ? { topic: topicWrite } : {},
-            parents: connectMany(parents),
-            tags: connectMany(tags),
-            relatedPosts: connectMany(relatedPosts),
-            ...coverImageWrite ? { coverImage: coverImageWrite } : {},
-            contentImages: connectMany(contentImages),
-            files1: connectMany(files1),
-            files2: connectMany(files2),
-            ...file1Write ? { file1: file1Write } : {},
-            ...file2Write ? { file2: file2Write } : {},
-            ...file3Write ? { file3: file3Write } : {},
-            ...file4Write ? { file4: file4Write } : {},
-            translations: { create: translations.map(translationToWrite) }
+        return withActiveFileReferences(
+          prisma,
+          [
+            input.coverImage,
+            ...input.contentImages,
+            ...input.files1,
+            ...input.files2,
+            input.file1,
+            input.file2,
+            input.file3,
+            input.file4
+          ],
+          async (transaction) => {
+            const id = ulid();
+            const {
+              author,
+              topic,
+              parents,
+              tags,
+              relatedPosts,
+              coverImage,
+              contentImages,
+              files1,
+              files2,
+              file1,
+              file2,
+              file3,
+              file4,
+              translations,
+              slug,
+              ...scalars
+            } = input;
+            const authorWrite = connectOne(author);
+            const topicWrite = connectOne(topic);
+            const coverImageWrite = connectOne(coverImage);
+            const file1Write = connectOne(file1);
+            const file2Write = connectOne(file2);
+            const file3Write = connectOne(file3);
+            const file4Write = connectOne(file4);
+            const post = await transaction.post.create({
+              data: {
+                ...scalars,
+                id,
+                slug: slug?.trim() || id,
+                ...authorWrite ? { author: authorWrite } : {},
+                ...topicWrite ? { topic: topicWrite } : {},
+                parents: connectMany(parents),
+                tags: connectMany(tags),
+                relatedPosts: connectMany(relatedPosts),
+                ...coverImageWrite ? { coverImage: coverImageWrite } : {},
+                contentImages: connectMany(contentImages),
+                files1: connectMany(files1),
+                files2: connectMany(files2),
+                ...file1Write ? { file1: file1Write } : {},
+                ...file2Write ? { file2: file2Write } : {},
+                ...file3Write ? { file3: file3Write } : {},
+                ...file4Write ? { file4: file4Write } : {},
+                translations: { create: translations.map(translationToWrite) }
+              }
+            });
+            return postToDomain(post);
           }
-        });
-        return postToDomain(post);
+        );
       },
       async update(input) {
-        const {
-          id,
-          author,
-          topic,
-          parents,
-          tags,
-          relatedPosts,
-          coverImage,
-          contentImages,
-          files1,
-          files2,
-          file1,
-          file2,
-          file3,
-          file4,
-          translations,
-          slug,
-          ...scalars
-        } = input;
-        const post = await prisma.post.update({
-          where: { id },
-          data: {
-            ...scalars,
-            slug: slug?.trim() || id,
-            author: connectOrDisconnectOne(author),
-            topic: connectOrDisconnectOne(topic),
-            parents: setMany(parents),
-            tags: setMany(tags),
-            relatedPosts: setMany(relatedPosts),
-            coverImage: connectOrDisconnectOne(coverImage),
-            contentImages: setMany(contentImages),
-            files1: setMany(files1),
-            files2: setMany(files2),
-            file1: connectOrDisconnectOne(file1),
-            file2: connectOrDisconnectOne(file2),
-            file3: connectOrDisconnectOne(file3),
-            file4: connectOrDisconnectOne(file4),
-            translations: {
-              upsert: translations.map((translation) => ({
-                where: {
-                  postId_locale: { postId: id, locale: translation.locale }
-                },
-                update: translationToWrite(translation),
-                create: translationToWrite(translation)
-              }))
-            }
+        return withActiveFileReferences(
+          prisma,
+          [
+            input.coverImage,
+            ...input.contentImages,
+            ...input.files1,
+            ...input.files2,
+            input.file1,
+            input.file2,
+            input.file3,
+            input.file4
+          ],
+          async (transaction) => {
+            const {
+              id,
+              author,
+              topic,
+              parents,
+              tags,
+              relatedPosts,
+              coverImage,
+              contentImages,
+              files1,
+              files2,
+              file1,
+              file2,
+              file3,
+              file4,
+              translations,
+              slug,
+              ...scalars
+            } = input;
+            const post = await transaction.post.update({
+              where: { id },
+              data: {
+                ...scalars,
+                slug: slug?.trim() || id,
+                author: connectOrDisconnectOne(author),
+                topic: connectOrDisconnectOne(topic),
+                parents: setMany(parents),
+                tags: setMany(tags),
+                relatedPosts: setMany(relatedPosts),
+                coverImage: connectOrDisconnectOne(coverImage),
+                contentImages: setMany(contentImages),
+                files1: setMany(files1),
+                files2: setMany(files2),
+                file1: connectOrDisconnectOne(file1),
+                file2: connectOrDisconnectOne(file2),
+                file3: connectOrDisconnectOne(file3),
+                file4: connectOrDisconnectOne(file4),
+                translations: {
+                  upsert: translations.map((translation) => ({
+                    where: {
+                      postId_locale: { postId: id, locale: translation.locale }
+                    },
+                    update: translationToWrite(translation),
+                    create: translationToWrite(translation)
+                  }))
+                }
+              }
+            });
+            return postToDomain(post);
           }
-        });
-        return postToDomain(post);
+        );
       },
       async delete({ id }) {
         return postToDomain(