sitero-server 0.0.1

package/dist/src/application/features/authentication/admin/operations/sign-out/admin-sign-out.js

@@ -0,0 +1,35 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+
+function createAdminSignOut(input) {
+  const {
+    authenticationTokenPort,
+    adminRefreshTokenQueryPort,
+    adminRefreshTokenCommandPort
+  } = input;
+  return createOperation(
+    {
+      behavior: { kind: "command" },
+      validate(input2) {
+        return input2;
+      }
+    },
+    async (input2) => {
+      if (input2.refreshToken) {
+        const tokenHash = authenticationTokenPort.hashRefreshToken(
+          input2.refreshToken
+        );
+        const currentToken = await adminRefreshTokenQueryPort.find({
+          tokenHash
+        });
+        if (currentToken) {
+          await adminRefreshTokenCommandPort.delete({ id: currentToken.id });
+        }
+      }
+      return operationResult.success({});
+    }
+  );
+}
+
+export { createAdminSignOut };

package/dist/src/application/features/authentication/admin/operations/verify/admin-verify.js

@@ -0,0 +1,21 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+
+function createAdminVerify(input) {
+  return createOperation(
+    {
+      authorization: { actorTypes: ["admin"] },
+      rateLimit: input?.rateLimit,
+      behavior: { kind: "query" }
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async (_, context) => {
+      return operationResult.success({
+        adminId: context.actor?.id ?? ""
+      });
+    }
+  );
+}
+
+export { createAdminVerify };

package/dist/src/application/features/authentication/admin/operations/verify-email/admin-verify-email.js

@@ -0,0 +1,57 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { createResourceTag } from '../../../../../conventions/cache/cache-tag.js';
+import { AdminVerifyEmailTokenInvalidError } from './errors.js';
+import { adminVerifyEmailInputSchema } from './validation.js';
+
+function createAdminVerifyEmail(input) {
+  const {
+    authenticationTokenPort,
+    adminQueryPort,
+    adminAuthenticationCommandPort,
+    rateLimit
+  } = input;
+  return createOperation(
+    {
+      behavior: {
+        kind: "command",
+        invalidate: {
+          tags: (_, result) => [
+            createResourceTag("admin"),
+            createResourceTag("admin", { id: result.data.admin.id }),
+            createResourceTag("admin", { email: result.data.admin.email })
+          ].flat()
+        }
+      },
+      rateLimit,
+      async validate(input2) {
+        return adminVerifyEmailInputSchema().parseAsync(input2);
+      }
+    },
+    async (input2) => {
+      let adminId;
+      try {
+        ({ adminId } = authenticationTokenPort.verifyAdminEmailVerificationToken({
+          token: input2.emailVerificationToken
+        }));
+      } catch {
+        throw new AdminVerifyEmailTokenInvalidError();
+      }
+      const admin = await adminQueryPort.find({
+        email: input2.email
+      });
+      if (!admin || admin.id !== adminId) {
+        throw new AdminVerifyEmailTokenInvalidError();
+      }
+      const updatedAdmin = await adminAuthenticationCommandPort.markEmailVerified({
+        adminId
+      });
+      return operationResult.success({
+        admin: updatedAdmin
+      });
+    }
+  );
+}
+
+export { createAdminVerifyEmail };

package/dist/src/application/features/authentication/admin/operations/verify-email/errors.js

@@ -0,0 +1,13 @@
+import { OperationError } from '../../../../../../contracts/operation/error.js';
+
+const ADMIN_VERIFY_EMAIL_ERROR_CODES = {
+  TOKEN_INVALID: "AUTH_ADMIN_VERIFY_EMAIL_TOKEN_INVALID"
+};
+class AdminVerifyEmailTokenInvalidError extends OperationError {
+  constructor() {
+    super({ code: ADMIN_VERIFY_EMAIL_ERROR_CODES.TOKEN_INVALID });
+    this.name = "AdminVerifyEmailTokenInvalidError";
+  }
+}
+
+export { ADMIN_VERIFY_EMAIL_ERROR_CODES, AdminVerifyEmailTokenInvalidError };

package/dist/src/application/features/authentication/admin/operations/verify-email/validation.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+const adminVerifyEmailInputSchema = () => z.object({
+  email: z.string().trim().toLowerCase().email(),
+  emailVerificationToken: z.string().min(1)
+});
+
+export { adminVerifyEmailInputSchema };

package/dist/src/application/features/authentication/token/create-authentication-tokens.js

@@ -0,0 +1,29 @@
+async function createAuthenticationTokens(input) {
+  const {
+    actor,
+    refreshTokenTtlSeconds,
+    authenticationTokenPort,
+    createActorRefreshToken
+  } = input;
+  const refreshToken = authenticationTokenPort.generateRefreshToken();
+  const tokenHash = authenticationTokenPort.hashRefreshToken(refreshToken);
+  const session = await createActorRefreshToken({
+    tokenHash,
+    expiresAt: new Date(Date.now() + refreshTokenTtlSeconds * 1e3)
+  });
+  const accessToken = authenticationTokenPort.signAccessToken({
+    actorId: actor.id,
+    actorType: actor.type,
+    sessionId: session.id,
+    role: actor.role
+  });
+  return {
+    tokens: {
+      accessToken,
+      refreshToken
+    },
+    session
+  };
+}
+
+export { createAuthenticationTokens };

package/dist/src/application/features/email-preview/operations/list-templates/list-templates.js

@@ -0,0 +1,21 @@
+import { createOperation } from '../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../contracts/operation/result.js';
+
+function createEmailPreviewListTemplatesOperation(input) {
+  const { authorization, emailTemplateCatalogPort, rateLimit } = input;
+  return createOperation(
+    {
+      authorization,
+      rateLimit,
+      behavior: { kind: "query" }
+    },
+    async () => {
+      return operationResult.success({
+        templates: await emailTemplateCatalogPort.list()
+      });
+    }
+  );
+}
+
+export { createEmailPreviewListTemplatesOperation };

package/dist/src/application/features/email-preview/operations/render-template/render-template.js

@@ -0,0 +1,22 @@
+import { createOperation } from '../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../contracts/operation/result.js';
+import { validateInput } from './validation.js';
+
+function createEmailPreviewRenderTemplateOperation(input) {
+  const { authorization, emailTemplateRendererPort, rateLimit } = input;
+  return createOperation(
+    {
+      authorization,
+      rateLimit,
+      behavior: { kind: "query" },
+      validate: validateInput
+    },
+    async (input2) => {
+      const preview = await emailTemplateRendererPort.render(input2);
+      return operationResult.success(preview);
+    }
+  );
+}
+
+export { createEmailPreviewRenderTemplateOperation };

package/dist/src/application/features/email-preview/operations/render-template/validation.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { requiredTextSchema } from '../../../../conventions/validation/schema.js';
+
+const emailPreviewRenderTemplateInputSchema = () => z.object({
+  key: requiredTextSchema(),
+  locale: requiredTextSchema().optional()
+});
+async function validateInput(input) {
+  return emailPreviewRenderTemplateInputSchema().parseAsync(input);
+}
+
+export { emailPreviewRenderTemplateInputSchema, validateInput };

package/dist/src/application/features/inquiry/operations/submit/cache.js

@@ -0,0 +1,8 @@
+import { createResourceTag } from '../../../../conventions/cache/cache-tag.js';
+
+const createInquirySubmitInvalidationTags = (_, result) => [
+  createResourceTag("inquiry"),
+  createResourceTag("inquiry", { id: result.data.inquiry.id })
+].flat();
+
+export { createInquirySubmitInvalidationTags };

package/dist/src/application/features/inquiry/operations/submit/inquiry-submit.js

@@ -0,0 +1,56 @@
+import { createOperation } from '../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../contracts/operation/result.js';
+import { notifyObserverSafely } from '../../../../../kernel/observer/notify-observer-safely.js';
+import { createInquirySubmitInvalidationTags } from './cache.js';
+import { validateInput } from './validation.js';
+
+function createInquirySubmitOperation(input) {
+  const {
+    inquiryCommandPort,
+    adminInquiryNotificationRecipientQueryPort,
+    newInquiryEmail,
+    observer,
+    rateLimit
+  } = input;
+  return createOperation(
+    {
+      behavior: {
+        kind: "command",
+        invalidate: { tags: createInquirySubmitInvalidationTags }
+      },
+      rateLimit,
+      validate: validateInput
+    },
+    async (input2, context) => {
+      const inquiry = await inquiryCommandPort.create(input2.formData);
+      if (newInquiryEmail) {
+        const recipients = await adminInquiryNotificationRecipientQueryPort.findInquiryNotificationRecipients();
+        if (recipients.length > 0) {
+          try {
+            await Promise.all(
+              recipients.map(async ({ email, preferredLocale }) => {
+                await newInquiryEmail({
+                  email,
+                  locale: preferredLocale
+                });
+              })
+            );
+          } catch (error) {
+            await notifyObserverSafely(
+              observer,
+              (observer2) => observer2.onEffectError?.({
+                context,
+                effect: "email",
+                error
+              })
+            );
+          }
+        }
+      }
+      return operationResult.success({ inquiry });
+    }
+  );
+}
+
+export { createInquirySubmitOperation };

package/dist/src/application/features/inquiry/operations/submit/validation.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { textSchema } from '../../../../conventions/validation/schema.js';
+
+const inquirySubmitInputSchema = () => z.object({
+  formData: z.object({
+    text1: textSchema().optional(),
+    text2: textSchema().optional(),
+    text3: textSchema().optional(),
+    text4: textSchema().optional(),
+    text5: textSchema().optional(),
+    text6: textSchema().optional(),
+    text7: textSchema().optional(),
+    text8: textSchema().optional(),
+    text9: textSchema().optional(),
+    text10: textSchema().optional()
+  })
+});
+async function validateInput(input) {
+  return inquirySubmitInputSchema().parseAsync(input);
+}
+
+export { inquirySubmitInputSchema, validateInput };

package/dist/src/application/features/uploads/constraints/create-storage-file-schema.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { isStorageFile } from '../../../../contracts/storage/file.js';
+import { UPLOAD_FIELD_ERROR_CODES } from '../validation-codes.js';
+
+function createStorageFileSchema(policy) {
+  return z.custom(isStorageFile).refine(
+    (file) => policy?.maxFileSizeInBytes === void 0 || file.size <= policy.maxFileSizeInBytes,
+    { message: UPLOAD_FIELD_ERROR_CODES.FILE_TOO_LARGE }
+  ).refine(
+    (file) => policy?.acceptedMimeTypes === void 0 || policy.acceptedMimeTypes.includes(file.type),
+    { message: UPLOAD_FIELD_ERROR_CODES.FILE_TYPE_NOT_ALLOWED }
+  );
+}
+
+export { createStorageFileSchema };

package/dist/src/application/features/uploads/operations/upload-file/upload-file.js

@@ -0,0 +1,35 @@
+import { createOperation } from '../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../contracts/operation/result.js';
+import { validateInput } from './validation.js';
+
+function createUploadFileOperation(input) {
+  const { authorization, policy, rateLimit, storageUploadPort } = input;
+  return createOperation(
+    {
+      authorization,
+      rateLimit,
+      behavior: { kind: "command" },
+      validate: (value) => validateInput(value, policy)
+    },
+    async (input2) => {
+      const { file } = input2;
+      const key = await storageUploadPort.upload({ file });
+      return operationResult.success({
+        uploadedFile: {
+          key,
+          fileMeta: {
+            name: file.name,
+            size: file.size,
+            type: file.type
+          },
+          width: file.width,
+          height: file.height,
+          duration: file.duration
+        }
+      });
+    }
+  );
+}
+
+export { createUploadFileOperation };

package/dist/src/application/features/uploads/operations/upload-file/validation.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { createStorageFileSchema } from '../../constraints/create-storage-file-schema.js';
+
+const uploadFileInputSchema = (policy) => z.object({
+  file: createStorageFileSchema(policy)
+});
+async function validateInput(input, policy) {
+  return uploadFileInputSchema(policy).parseAsync(input);
+}
+
+export { uploadFileInputSchema, validateInput };

package/dist/src/application/features/uploads/operations/upload-files/upload-files.js

@@ -0,0 +1,48 @@
+import pLimit from 'p-limit';
+import { createOperation } from '../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../contracts/operation/result.js';
+import { validateInput } from './validation.js';
+
+const DEFAULT_UPLOAD_FILES_CONCURRENCY = 5;
+function createUploadFilesOperation(input) {
+  const {
+    authorization,
+    concurrency = DEFAULT_UPLOAD_FILES_CONCURRENCY,
+    rateLimit,
+    storageUploadPort,
+    policy
+  } = input;
+  return createOperation(
+    {
+      authorization,
+      rateLimit,
+      behavior: { kind: "command" },
+      validate: (value) => validateInput(value, policy)
+    },
+    async (input2) => {
+      const limit = pLimit(concurrency);
+      const uploadedFiles = await Promise.all(
+        input2.files.map(
+          (file) => limit(async () => {
+            const key = await storageUploadPort.upload({ file });
+            return {
+              key,
+              fileMeta: {
+                name: file.name,
+                size: file.size,
+                type: file.type
+              },
+              width: file.width,
+              height: file.height,
+              duration: file.duration
+            };
+          })
+        )
+      );
+      return operationResult.success({ uploadedFiles });
+    }
+  );
+}
+
+export { createUploadFilesOperation };

package/dist/src/application/features/uploads/operations/upload-files/validation.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { createStorageFileSchema } from '../../constraints/create-storage-file-schema.js';
+import { UPLOAD_FIELD_ERROR_CODES } from '../../validation-codes.js';
+
+const uploadFilesInputSchema = (policy) => z.object({
+  files: z.array(createStorageFileSchema(policy)).refine(
+    (files) => policy?.maxFilesPerRequest === void 0 || files.length <= policy.maxFilesPerRequest,
+    { message: UPLOAD_FIELD_ERROR_CODES.TOO_MANY_FILES }
+  ).refine(
+    (files) => policy?.maxTotalSizeInBytes === void 0 || files.reduce((total, file) => total + file.size, 0) <= policy.maxTotalSizeInBytes,
+    { message: UPLOAD_FIELD_ERROR_CODES.TOTAL_SIZE_TOO_LARGE }
+  )
+});
+async function validateInput(input, policy) {
+  return uploadFilesInputSchema(policy).parseAsync(input);
+}
+
+export { uploadFilesInputSchema, validateInput };

package/dist/src/application/features/uploads/validation-codes.js

@@ -0,0 +1,8 @@
+const UPLOAD_FIELD_ERROR_CODES = {
+  FILE_TOO_LARGE: "validation.file.too_large",
+  FILE_TYPE_NOT_ALLOWED: "validation.file.type_not_allowed",
+  TOO_MANY_FILES: "validation.files.too_many",
+  TOTAL_SIZE_TOO_LARGE: "validation.files.total_size_too_large"
+};
+
+export { UPLOAD_FIELD_ERROR_CODES };

package/dist/src/application/resources/admin/constraints/assert-admin-email-unique.js

@@ -0,0 +1,11 @@
+import { AdminEmailAlreadyExistsError } from '../errors/operation-errors.js';
+
+async function assertAdminEmailUnique(input) {
+  const { email, excludeAdminId, adminQueryPort } = input;
+  const admin = await adminQueryPort.find({ email });
+  if (admin && admin.id !== excludeAdminId) {
+    throw new AdminEmailAlreadyExistsError();
+  }
+}
+
+export { assertAdminEmailUnique };

package/dist/src/application/resources/admin/constraints/assert-admin-readable.js

@@ -0,0 +1,13 @@
+import { ADMIN_ROLES } from 'sitero-domain';
+import { AdminReadForbiddenError } from '../errors/operation-errors.js';
+
+function assertAdminReadable(input) {
+  const { actor, targetAdminId } = input;
+  const isSelf = actor?.id === targetAdminId;
+  const canReadOthers = actor?.role === ADMIN_ROLES.SUPER_ADMIN;
+  if (!isSelf && !canReadOthers) {
+    throw new AdminReadForbiddenError();
+  }
+}
+
+export { assertAdminReadable };

package/dist/src/application/resources/admin/errors/codes.js

@@ -0,0 +1,13 @@
+const ADMIN_ERROR_CODES = {
+  NOT_FOUND: "ADMIN_NOT_FOUND",
+  EMAIL_ALREADY_EXISTS: "ADMIN_EMAIL_ALREADY_EXISTS",
+  READ_FORBIDDEN: "ADMIN_READ_FORBIDDEN",
+  UPDATE_FORBIDDEN: "ADMIN_UPDATE_FORBIDDEN",
+  DELETE_FORBIDDEN: "ADMIN_DELETE_FORBIDDEN",
+  DELETE_PROTECTED: "ADMIN_DELETE_PROTECTED"
+};
+const ADMIN_FIELD_ERROR_CODES = {
+  EMAIL_ALREADY_EXISTS: "validation.email.already_exists"
+};
+
+export { ADMIN_ERROR_CODES, ADMIN_FIELD_ERROR_CODES };

package/dist/src/application/resources/admin/errors/operation-errors.js

@@ -0,0 +1,49 @@
+import { OperationError } from '../../../../contracts/operation/error.js';
+import { ADMIN_ERROR_CODES, ADMIN_FIELD_ERROR_CODES } from './codes.js';
+
+class AdminNotFoundError extends OperationError {
+  constructor() {
+    super({ code: ADMIN_ERROR_CODES.NOT_FOUND });
+    this.name = "AdminNotFoundError";
+  }
+}
+class AdminEmailAlreadyExistsError extends OperationError {
+  constructor() {
+    super({
+      code: ADMIN_ERROR_CODES.EMAIL_ALREADY_EXISTS,
+      fields: [
+        {
+          path: ["email"],
+          code: ADMIN_FIELD_ERROR_CODES.EMAIL_ALREADY_EXISTS
+        }
+      ]
+    });
+    this.name = "AdminEmailAlreadyExistsError";
+  }
+}
+class AdminDeleteProtectedError extends OperationError {
+  constructor() {
+    super({ code: ADMIN_ERROR_CODES.DELETE_PROTECTED });
+    this.name = "AdminDeleteProtectedError";
+  }
+}
+class AdminUpdateForbiddenError extends OperationError {
+  constructor() {
+    super({ code: ADMIN_ERROR_CODES.UPDATE_FORBIDDEN });
+    this.name = "AdminUpdateForbiddenError";
+  }
+}
+class AdminDeleteForbiddenError extends OperationError {
+  constructor() {
+    super({ code: ADMIN_ERROR_CODES.DELETE_FORBIDDEN });
+    this.name = "AdminDeleteForbiddenError";
+  }
+}
+class AdminReadForbiddenError extends OperationError {
+  constructor() {
+    super({ code: ADMIN_ERROR_CODES.READ_FORBIDDEN });
+    this.name = "AdminReadForbiddenError";
+  }
+}
+
+export { AdminDeleteForbiddenError, AdminDeleteProtectedError, AdminEmailAlreadyExistsError, AdminNotFoundError, AdminReadForbiddenError, AdminUpdateForbiddenError };

package/dist/src/application/resources/admin/operations/commands/create/admin-create-command.js

@@ -0,0 +1,63 @@
+import { ADMIN_ROLES } from 'sitero-domain';
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { notifyObserverSafely } from '../../../../../../kernel/observer/notify-observer-safely.js';
+import { createAdminCreateCacheTags } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+function createAdminCreateCommand(input) {
+  const {
+    authorization,
+    adminCommandPort,
+    adminQueryPort,
+    fileQueryPort,
+    authenticationPasswordPort,
+    adminVerificationEmail,
+    observer
+  } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "command",
+        invalidate: {
+          tags: createAdminCreateCacheTags
+        }
+      },
+      async validate(input2) {
+        return validateInput({ input: input2, adminQueryPort, fileQueryPort });
+      }
+    },
+    async (input2, context) => {
+      const { password, ...rest } = input2;
+      const passwordHash = await authenticationPasswordPort.hashPassword(password);
+      const admin = await adminCommandPort.create({
+        ...rest,
+        passwordHash,
+        role: ADMIN_ROLES.ADMIN
+      });
+      try {
+        await adminVerificationEmail.sender({
+          adminId: admin.id,
+          email: admin.email,
+          locale: admin.preferredLocale
+        });
+      } catch (error) {
+        await notifyObserverSafely(
+          observer,
+          (observer2) => observer2.onEffectError?.({
+            context,
+            effect: "email",
+            error
+          })
+        );
+      }
+      return operationResult.success({
+        admin
+      });
+    }
+  );
+}
+
+export { createAdminCreateCommand };

package/dist/src/application/resources/admin/operations/commands/create/cache.js

@@ -0,0 +1,16 @@
+import { createResourceTag, createRelationTag } from '../../../../../conventions/cache/cache-tag.js';
+
+const createAdminCreateCacheTags = (_, result) => {
+  const { admin } = result.data;
+  return [
+    createResourceTag("admin"),
+    createResourceTag("admin", { id: admin.id }),
+    createResourceTag("admin", { email: admin.email }),
+    ...admin.avatarImageId ? [
+      createResourceTag("file", { id: admin.avatarImageId }),
+      createRelationTag("admin", "avatarImage", { id: admin.id })
+    ] : []
+  ].flat();
+};
+
+export { createAdminCreateCacheTags };