sitero 0.2.0 → 0.4.0

package/dist/src/cms/server/resources/seo-metadata/actions.js

@@ -12,7 +12,12 @@ function normalizeJsonLd(data) {
   if (Array.isArray(data)) return data.filter(isObject);
   if (typeof data === "string") {
     if (data.trim() === "") return [];
-    const parsed = JSON.parse(data);
+    let parsed;
+    try {
+      parsed = JSON.parse(data);
+    } catch {
+      return null;
+    }
     if (Array.isArray(parsed)) return parsed.filter(isObject);
     if (isObject(parsed)) return [parsed];
     return [];
@@ -27,24 +32,53 @@ function createSeoMetadataActions({
   const seoMetadataUpsertAction = async (input) => {
     const contextResult = await resolveExecutionContext();
     if (!contextResult.success) return contextResult;
+    const invalidJsonLdIndexes = [];
+    const translations = input.formData.translations.map(
+      (translation, index) => {
+        const jsonLd = normalizeJsonLd(translation.jsonLd);
+        if (jsonLd === null) invalidJsonLdIndexes.push(index);
+        return {
+          ...translation,
+          ogArticlePublishedTime: normalizeDatetime(
+            translation.ogArticlePublishedTime
+          ),
+          ogArticleModifiedTime: normalizeDatetime(
+            translation.ogArticleModifiedTime
+          ),
+          // Keep server validation running for every other submitted field.
+          jsonLd: jsonLd ?? []
+        };
+      }
+    );
     const formData = {
       ...input.formData,
-      translations: input.formData.translations.map((translation) => ({
-        ...translation,
-        ogArticlePublishedTime: normalizeDatetime(
-          translation.ogArticlePublishedTime
-        ),
-        ogArticleModifiedTime: normalizeDatetime(
-          translation.ogArticleModifiedTime
-        ),
-        jsonLd: normalizeJsonLd(translation.jsonLd)
-      }))
+      translations
     };
-    return await siteroServer.executor.execute(
+    const result = await siteroServer.executor.execute(
       siteroServer.resources.seoMetadata.upsert,
       formData,
       contextResult.data
     );
+    const jsonLdFields = invalidJsonLdIndexes.map((index) => ({
+      path: ["translations", index, "jsonLd"],
+      kind: "custom",
+      code: "validation.json.invalid"
+    }));
+    if (jsonLdFields.length === 0) return result;
+    if (result.success) {
+      return {
+        success: false,
+        error: { code: "VALIDATION_FAILED", fields: jsonLdFields }
+      };
+    }
+    if (result.error.code !== "VALIDATION_FAILED") return result;
+    return {
+      success: false,
+      error: {
+        ...result.error,
+        fields: [...result.error.fields ?? [], ...jsonLdFields]
+      }
+    };
   };
   return {
     upsert: seoMetadataUpsertAction

package/dist/src/config/author.js

@@ -0,0 +1,13 @@
+const AUTHOR_FIELDS = [
+  "authorName",
+  "socialLinks",
+  "description",
+  "jobTitle",
+  "url",
+  "worksFor",
+  "knowsAbout",
+  "homeLocation",
+  "nationality"
+];
+
+export { AUTHOR_FIELDS };

package/dist/src/config/post.js

@@ -0,0 +1,14 @@
+const POST_CUSTOM_STATE_FIELDS = [
+  "state1",
+  "state2",
+  "state3",
+  "state4",
+  "state5",
+  "state6",
+  "state7",
+  "state8",
+  "state9",
+  "state10"
+];
+
+export { POST_CUSTOM_STATE_FIELDS };

package/dist/src/core/infrastructure/email/catalog.js

@@ -1,13 +1,6 @@
 import 'sitero-domain';
 import { EMAIL_DEFINITION_KEYS } from '../../../config/emails.js';
 
-function assertRelativeEmailAssetPath(value, label) {
-  const normalized = value;
-  const segments = normalized.split("/");
-  if (!normalized || normalized !== normalized.trim() || normalized.includes("\\") || normalized.includes(":") || normalized.startsWith("/") || segments.some((segment) => !segment || segment === "." || segment === "..")) {
-    throw new Error(`${label} must be a safe relative email asset path`);
-  }
-}
 function validateEmailCatalog(catalog) {
   for (const key of Object.values(EMAIL_DEFINITION_KEYS)) {
     if (!Object.hasOwn(catalog, key)) {
@@ -15,10 +8,6 @@ function validateEmailCatalog(catalog) {
     }
   }
   for (const [key, definition] of Object.entries(catalog)) {
-    assertRelativeEmailAssetPath(
-      definition.presentation,
-      `Email definition ${key} presentation`
-    );
     const fallback = definition.locales[definition.fallbackLocale];
     if (!Object.hasOwn(definition.locales, definition.fallbackLocale) || !fallback) {
       throw new Error(
@@ -34,10 +23,11 @@ function validateEmailCatalog(catalog) {
           `Email definition ${key} has an empty subject for locale: ${locale}`
         );
       }
-      assertRelativeEmailAssetPath(
-        localized.contentPath,
-        `Email definition ${key} contentPath for locale ${locale}`
-      );
+      if (typeof localized.render !== "function") {
+        throw new Error(
+          `Email definition ${key} has no renderer for locale: ${locale}`
+        );
+      }
     }
   }
 }

package/dist/src/core/infrastructure/email/react-email-composer.js

@@ -0,0 +1,50 @@
+import { isValidElement } from 'react';
+import { render, toPlainText } from 'react-email';
+import { validateEmailCatalog, resolveEmailLocaleDefinition } from './catalog.js';
+
+function createReactEmailComposer({
+  catalog,
+  url,
+  logoUrl,
+  siteName,
+  logger
+}) {
+  validateEmailCatalog(catalog);
+  return {
+    async compose({
+      locale,
+      key,
+      replacements = {}
+    }) {
+      try {
+        const resolved = resolveEmailLocaleDefinition(catalog, key, locale);
+        const name = siteName[resolved.locale] ?? siteName[resolved.definition.fallbackLocale];
+        if (!name?.trim())
+          throw new Error(
+            `Email site name missing for locale: ${resolved.locale}`
+          );
+        const element = resolved.localized.render({
+          locale: resolved.locale,
+          webUrl: url,
+          logoUrl,
+          siteName: name,
+          replacements
+        });
+        if (!isValidElement(element))
+          throw new Error(`Email renderer must return a React element: ${key}`);
+        const html = await render(element);
+        return {
+          subject: resolved.localized.subject,
+          html,
+          text: toPlainText(html),
+          locale: resolved.locale
+        };
+      } catch (error) {
+        logger.error({ msg: "Email template render failed", key, error });
+        throw new Error(`Email template error: ${key}`, { cause: error });
+      }
+    }
+  };
+}
+
+export { createReactEmailComposer };

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/admin-refresh-token/admin-refresh-token-prisma-ports.js

@@ -18,6 +18,46 @@ function createAdminRefreshTokenPrismaPorts(prisma) {
           })
         );
       },
+      async rotate({
+        id,
+        currentTokenHash,
+        nextTokenHash,
+        expiresAt,
+        lastIp,
+        lastUsedAt
+      }) {
+        return prisma.$transaction(async (transaction) => {
+          const { count } = await transaction.adminRefreshToken.updateMany({
+            where: {
+              id,
+              tokenHash: currentTokenHash,
+              expiresAt: { gt: lastUsedAt }
+            },
+            data: {
+              tokenHash: nextTokenHash,
+              expiresAt,
+              lastIp,
+              lastUsedAt
+            }
+          });
+          if (count === 0) {
+            return null;
+          }
+          await transaction.adminRefreshTokenReplay.create({
+            data: {
+              tokenHash: currentTokenHash,
+              adminRefreshTokenId: id,
+              expiresAt
+            }
+          });
+          const session = await transaction.adminRefreshToken.findUniqueOrThrow(
+            {
+              where: { id }
+            }
+          );
+          return adminRefreshTokenToDomain(session);
+        });
+      },
       async delete({ id }) {
         await prisma.adminRefreshToken.delete({ where: { id } });
       },
@@ -47,10 +87,17 @@ function createAdminRefreshTokenPrismaPorts(prisma) {
         });
         return refreshToken ? adminRefreshTokenToDomain(refreshToken) : null;
       },
+      async findReplay({ tokenHash }) {
+        const replay = await prisma.adminRefreshTokenReplay.findUnique({
+          where: { tokenHash },
+          select: { adminRefreshTokenId: true }
+        });
+        return replay ? { sessionId: replay.adminRefreshTokenId } : null;
+      },
       async findMany({ adminId }) {
         const refreshTokens = await prisma.adminRefreshToken.findMany({
           where: { adminId },
-          orderBy: [{ createdAt: "desc" }, { id: "asc" }]
+          orderBy: [{ lastUsedAt: "desc" }, { id: "asc" }]
         });
         return refreshTokens.map(adminRefreshTokenToDomain);
       }

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

@@ -1,7 +1,7 @@
 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';
+import { FILE_RELATIONS_INCLUDE, FILE_NOT_IN_USE_WHERE, FILE_USAGE_COUNT_SELECT, FILE_DETAIL_INCLUDE } from './include.js';
+import { fileRelationsToDomain, fileDetailToDomain, toFileContentData } from './mappers.js';
 
 const SEARCH_ROOT_FIELDS = [
   "originalName"
@@ -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 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);
-      },
-      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
     // ------------------------------------------------------------
+    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);
       }
     },
     // ------------------------------------------------------------
@@ -128,7 +173,7 @@ function createFilePrismaPorts(prisma) {
               fields: SEARCH_TRANSLATION_FIELDS
             }
           }),
-          ...input.type ? { type: input.type } : {},
+          ...input.types !== void 0 ? { type: { in: input.types } } : {},
           ...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 } } : {}
@@ -163,6 +208,15 @@ function createFilePrismaPorts(prisma) {
           total
         };
       }
+    },
+    fileRelationsQueryPort: {
+      async findRelations({ id }) {
+        const file = await prisma.file.findUnique({
+          where: { id },
+          include: FILE_RELATIONS_INCLUDE
+        });
+        return file ? fileRelationsToDomain(file) : null;
+      }
     }
   };
 }