sitero 0.0.1

package/dist/src/core/server/infrastructure/zod/zod.js

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { bcp47 } from './rules/bcp47.js';
+import { ogLocale } from './rules/og-locale.js';
+
+function createZod({
+  unique,
+  exist
+}) {
+  const stringProto = z.string().constructor.prototype;
+  const emailProto = z.email().constructor.prototype;
+  if (!stringProto.unique) {
+    Object.defineProperty(stringProto, "unique", {
+      configurable: true,
+      writable: false,
+      value: function(options) {
+        return this.refine(async (v) => unique(v, options), {
+          params: { i18nKey: "validator.unique" }
+        });
+      }
+    });
+  }
+  if (!stringProto.exist) {
+    Object.defineProperty(stringProto, "exist", {
+      configurable: true,
+      writable: false,
+      value: function(options) {
+        return this.refine(async (v) => exist(v, options), {
+          params: { i18nKey: "validator.exist" }
+        });
+      }
+    });
+  }
+  if (!stringProto.bcp47) {
+    Object.defineProperty(stringProto, "bcp47", {
+      configurable: true,
+      writable: false,
+      value: function() {
+        return this.refine((v) => bcp47(v), {
+          params: { i18nKey: "validator.bcp47" }
+        });
+      }
+    });
+  }
+  if (!stringProto.ogLocale) {
+    Object.defineProperty(stringProto, "ogLocale", {
+      configurable: true,
+      writable: false,
+      value: function() {
+        return this.refine((v) => ogLocale(v), {
+          params: { i18nKey: "validator.og-locale" }
+        });
+      }
+    });
+  }
+  if (!emailProto.unique) {
+    Object.defineProperty(emailProto, "unique", {
+      configurable: true,
+      writable: false,
+      value: function(options) {
+        return this.refine(async (v) => unique(v, options), {
+          params: { i18nKey: "validator.unique" }
+        });
+      }
+    });
+  }
+  return z;
+}
+
+export { createZod };

package/dist/src/core/server/interfaces/actions/admin/change-password/change-password-action.js

@@ -0,0 +1,33 @@
+import { changePasswordValidator } from './change-password-validator.js';
+
+function createAdminChangePasswordAction(ctx) {
+  const {
+    infrastructure: { cache, zod },
+    applications: { useCases: auth },
+    interfaces: { executions, middlewares }
+  } = ctx;
+  return async function adminChangePasswordAction({
+    formData
+  }) {
+    return executions.executeAction(
+      async () => {
+        await cache.ipRateLimiter({ key: ["change-password"] });
+        const { email } = await middlewares.admin.adminAuthMiddleware.authenticate();
+        const { password, newPassword } = await changePasswordValidator(
+          zod.schemas
+        ).parseAsync(formData);
+        await auth.adminAuthUseCases.verifyCredentials({ email, password });
+        await auth.adminAuthUseCases.updatePassword({
+          email,
+          password: newPassword
+        });
+        return {
+          i18nKey: "ok.change-password-ok"
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createAdminChangePasswordAction };

package/dist/src/core/server/interfaces/actions/admin/change-password/change-password-validator.js

@@ -0,0 +1,20 @@
+const changePasswordValidator = (schemas) => schemas.z.object({
+  password: schemas.password(),
+  newPassword: schemas.password(),
+  newPasswordConfirm: schemas.password()
+}).superRefine((data, ctx) => {
+  if (data.newPassword !== data.newPasswordConfirm) {
+    ctx.addIssue({
+      code: "custom",
+      params: { i18nKey: "validator.password-confirm" },
+      path: ["newPassword"]
+    });
+    ctx.addIssue({
+      code: "custom",
+      params: { i18nKey: "validator.password-confirm" },
+      path: ["newPasswordConfirm"]
+    });
+  }
+});
+
+export { changePasswordValidator };

package/dist/src/core/server/interfaces/actions/admin/email-unverifired/email-unverifired-action.js

@@ -0,0 +1,40 @@
+import { ServerError } from '../../../../server-error.js';
+import { emailUnverifiedValidator } from './email-unverifired-validator.js';
+
+function createAdminEmailUnverifiedAction(ctx) {
+  const {
+    infrastructure: { cache, zod, repositories },
+    applications: { emails, useCases: auth },
+    interfaces: { executions }
+  } = ctx;
+  return async function adminEmailUnverifiedAction({
+    formData
+  }) {
+    return executions.executeAction(
+      async (translator) => {
+        await cache.ipRateLimiter({
+          key: ["email-unverified"],
+          maxAttempts: 2,
+          timeWindow: 60
+        });
+        const { email } = await emailUnverifiedValidator(
+          zod.schemas
+        ).parseAsync(formData);
+        const admin = await repositories.adminQueryRepository.find({ email });
+        if (!admin) throw new ServerError({ i18nKey: "error.email-not-found" });
+        const emailVerificationToken = auth.adminAuthUseCases.signEmailVerificationToken();
+        void emails.adminEmailVerificationEmail.send({
+          translator,
+          email: admin.email,
+          emailVerificationToken
+        });
+        return {
+          i18nKey: "ok.email-unverified-ok"
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createAdminEmailUnverifiedAction };

package/dist/src/core/server/interfaces/actions/admin/email-unverifired/email-unverifired-validator.js

@@ -0,0 +1,5 @@
+const emailUnverifiedValidator = (schemas) => schemas.z.object({
+  email: schemas.email()
+});
+
+export { emailUnverifiedValidator };

package/dist/src/core/server/interfaces/actions/admin/forgot-password/forgot-password-action.js

@@ -0,0 +1,40 @@
+import { ServerError } from '../../../../server-error.js';
+import { forgetPasswordValidator } from './forgot-password-validator.js';
+
+function createAdminForgotPasswordAction(ctx) {
+  const {
+    infrastructure: { cache, zod, repositories },
+    applications: { useCases: auth, emails },
+    interfaces: { executions }
+  } = ctx;
+  return async function adminForgotPasswordAction({
+    formData
+  }) {
+    return executions.executeAction(
+      async (translator) => {
+        await cache.ipRateLimiter({
+          key: ["forget-password"],
+          maxAttempts: 2,
+          timeWindow: 60
+        });
+        const { email } = await forgetPasswordValidator(zod.schemas).parseAsync(
+          formData
+        );
+        const admin = await repositories.adminQueryRepository.find({ email });
+        if (!admin) throw new ServerError({ i18nKey: "error.email-not-found" });
+        const token = auth.adminAuthUseCases.signPasswordResetToken({ admin });
+        void emails.adminForgotPasswordEmail.send({
+          translator,
+          email: admin.email,
+          passwordResetToken: token
+        });
+        return {
+          i18nKey: "ok.forgot-password-ok"
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createAdminForgotPasswordAction };

package/dist/src/core/server/interfaces/actions/admin/forgot-password/forgot-password-validator.js

@@ -0,0 +1,5 @@
+const forgetPasswordValidator = (schemas) => schemas.z.object({
+  email: schemas.email()
+});
+
+export { forgetPasswordValidator };

package/dist/src/core/server/interfaces/actions/admin/reset-password/reset-password-action.js

@@ -0,0 +1,32 @@
+import { resetPasswordValidator } from './reset-password-validator.js';
+
+function createAdminResetPasswordAction(ctx) {
+  const {
+    infrastructure: { cache, zod },
+    applications: { useCases: auth },
+    interfaces: { executions }
+  } = ctx;
+  return async function adminResetPasswordAction({
+    formData
+  }) {
+    return executions.executeAction(
+      async () => {
+        await cache.ipRateLimiter({ key: ["reset-password"] });
+        const { newPassword, passwordResetToken } = await resetPasswordValidator(zod.schemas).parseAsync(formData);
+        const decoded = auth.adminAuthUseCases.verifyPasswordResetToken({
+          token: passwordResetToken
+        });
+        await auth.adminAuthUseCases.updatePassword({
+          email: decoded.email,
+          password: newPassword
+        });
+        return {
+          i18nKey: "ok.reset-password-ok"
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createAdminResetPasswordAction };

package/dist/src/core/server/interfaces/actions/admin/reset-password/reset-password-validator.js

@@ -0,0 +1,20 @@
+const resetPasswordValidator = (schemas) => schemas.z.object({
+  passwordResetToken: schemas.z.string().trim().max(1e3),
+  newPassword: schemas.password(),
+  newPasswordConfirm: schemas.password()
+}).superRefine((data, ctx) => {
+  if (data.newPassword !== data.newPasswordConfirm) {
+    ctx.addIssue({
+      code: "custom",
+      message: "custom.password-confirm",
+      path: ["newPassword"]
+    });
+    ctx.addIssue({
+      code: "custom",
+      message: "custom.password-confirm",
+      path: ["newPasswordConfirm"]
+    });
+  }
+});
+
+export { resetPasswordValidator };

package/dist/src/core/server/interfaces/actions/admin/sign-in/sign-in-action.js

@@ -0,0 +1,45 @@
+import { ServerError } from '../../../../server-error.js';
+import { signInValidator } from './sign-in-validator.js';
+
+function createAdminSignInAction(ctx) {
+  const {
+    infrastructure: { cache, zod, repositories },
+    applications: { useCases: auth },
+    interfaces: { executions },
+    next: { headers }
+  } = ctx;
+  return async function adminSignInAction({
+    formData,
+    deviceInfo
+  }) {
+    return executions.executeAction(
+      async () => {
+        await cache.ipRateLimiter({ key: ["sign-in"] });
+        const { email, password } = await signInValidator(
+          zod.schemas
+        ).parseAsync(formData);
+        const verified = await auth.adminAuthUseCases.verifyCredentials({
+          email,
+          password
+        });
+        const admin = await repositories.adminQueryRepository.findFull({
+          id: verified.id
+        });
+        if (!admin) throw ServerError.notFound();
+        await auth.adminAuthUseCases.refreshTokens({
+          admin,
+          deviceInfo,
+          ip: (await headers()).get("x-forwarded-for") || "unknown"
+        });
+        await repositories.adminRefreshTokenCommandRepository.deleteManyByExpired();
+        return {
+          i18nKey: "ok.sign-in-ok",
+          data: { admin }
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createAdminSignInAction };

package/dist/src/core/server/interfaces/actions/admin/sign-in/sign-in-validator.js

@@ -0,0 +1,6 @@
+const signInValidator = (schemas) => schemas.z.object({
+  email: schemas.email(),
+  password: schemas.password()
+});
+
+export { signInValidator };

package/dist/src/core/server/interfaces/actions/admin/sign-out/sign-out-action.js

@@ -0,0 +1,33 @@
+function createAdminSignOutAction(ctx) {
+  const {
+    infrastructure: { services, repositories },
+    interfaces: { executions },
+    constants: { accessTokenName, refreshTokenName }
+  } = ctx;
+  return async function adminSignOutAction() {
+    return executions.executeAction(
+      async () => {
+        let token;
+        try {
+          token = await services.cookieService.getSignedCookie({
+            name: refreshTokenName
+          });
+        } catch {
+        }
+        if (token) {
+          await repositories.adminRefreshTokenCommandRepository.delete({
+            tokenHash: services.cryptoService.hash(token)
+          });
+        }
+        await services.cookieService.delete({ name: accessTokenName });
+        await services.cookieService.delete({ name: refreshTokenName });
+        return {
+          i18nKey: "ok.sign-out-ok"
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createAdminSignOutAction };

package/dist/src/core/server/interfaces/actions/admin/verify/verify-action.js

@@ -0,0 +1,17 @@
+function createAdminVerifyAction(ctx) {
+  const {
+    infrastructure: { cache },
+    interfaces: { executions, middlewares }
+  } = ctx;
+  return async function adminVerifyAction() {
+    return executions.executeAction(async () => {
+      await cache.ipRateLimiter({ key: ["verify"], maxAttempts: 60 });
+      const admin = await middlewares.admin.adminAuthMiddleware.authenticate();
+      return {
+        data: { admin }
+      };
+    });
+  };
+}
+
+export { createAdminVerifyAction };

package/dist/src/core/server/interfaces/actions/admin/verify-email/verify-email-action.js

@@ -0,0 +1,35 @@
+import { ServerError } from '../../../../server-error.js';
+import { verifyEmailValidator } from './verify-email-validator.js';
+
+function createAdminVerifyEmailAction(ctx) {
+  const {
+    infrastructure: { cache, zod, repositories },
+    applications: { useCases: auth },
+    interfaces: { executions }
+  } = ctx;
+  return async function adminVerifyEmailAction({
+    formData
+  }) {
+    return executions.executeAction(
+      async () => {
+        await cache.ipRateLimiter({ key: ["verify-email"] });
+        const { email, emailVerificationToken } = await verifyEmailValidator(
+          zod.schemas
+        ).parseAsync(formData);
+        const admin = await repositories.adminQueryRepository.find({ email });
+        if (!admin) throw new ServerError({ i18nKey: "error.email-not-found" });
+        await auth.adminAuthUseCases.verifyEmailAndUpdate({
+          token: emailVerificationToken || "",
+          admin
+        });
+        return {
+          i18nKey: "ok.verify-email-ok",
+          data: { admin }
+        };
+      },
+      { type: "command" }
+    );
+  };
+}
+
+export { createAdminVerifyEmailAction };

package/dist/src/core/server/interfaces/actions/admin/verify-email/verify-email-validator.js

@@ -0,0 +1,6 @@
+const verifyEmailValidator = (schemas) => schemas.z.object({
+  email: schemas.email(),
+  emailVerificationToken: schemas.z.string().trim().max(1e3)
+});
+
+export { verifyEmailValidator };

package/dist/src/core/server/interfaces/apis/emails/emails-api.js

@@ -0,0 +1,121 @@
+import { NextResponse } from 'next/server';
+import '../../../../../constants/paths/auth.js';
+import '../../../../../constants/paths/main.js';
+import '../../../../../constants/paths/resources.js';
+import '../../../../../constants/redirect-paths.js';
+import { EMAILS } from '../../../../../constants/emails.js';
+
+function createEmailsApi(ctx) {
+  const { infrastructure, interfaces } = ctx;
+  return function emailsApi() {
+    return interfaces.executions.executeApi(async () => {
+      await infrastructure.cache.ipRateLimiter({
+        key: ["emails"],
+        maxAttempts: 60
+      });
+      await interfaces.middlewares.admin.adminAuthMiddleware.authenticate();
+      const html = `
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>CMS Email Templates</title>
+    <style>
+      * {
+        box-sizing: border-box;
+        margin: 0;
+        padding: 0;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, sans-serif;
+      }
+
+      body {
+        background: #0b0b0c;
+        color: #e5e5e5;
+        padding: 48px;
+      }
+
+      .container {
+        max-width: 720px;
+        margin: 0 auto;
+      }
+
+      h1 {
+        font-size: 28px;
+        font-weight: 600;
+        margin-bottom: 32px;
+        letter-spacing: -0.02em;
+      }
+
+      ul {
+        list-style: none;
+        display: flex;
+        flex-direction: column;
+        gap: 12px;
+      }
+
+      a {
+        display: block;
+        text-decoration: none;
+        color: inherit;
+        background: #151517;
+        border: 1px solid #222226;
+        border-radius: 10px;
+        padding: 16px 18px;
+        transition: all 0.15s ease;
+      }
+
+      a:hover {
+        border-color: #3a3a40;
+        background: #1a1a1d;
+        transform: translateY(-1px);
+      }
+
+      .key {
+        font-weight: 500;
+        font-size: 15px;
+      }
+
+      .path {
+        font-size: 12px;
+        color: #9ca3af;
+        margin-top: 4px;
+      }
+
+      footer {
+        margin-top: 40px;
+        font-size: 12px;
+        color: #6b7280;
+      }
+    </style>
+  </head>
+
+  <body>
+    <div class="container">
+      <h1>CMS Email Templates</h1>
+
+      <ul>
+        ${Object.entries(EMAILS).map(
+        ([key, { filePath }]) => `
+          <li>
+            <a href="/api/v1/cms/emails/${filePath}">
+              <div class="key">${key}</div>
+              <div class="path">/api/v1/cms/emails/${filePath}</div>
+            </a>
+          </li>
+        `
+      ).join("")}
+      </ul>
+
+      <footer>Internal preview endpoint</footer>
+    </div>
+  </body>
+</html>
+`;
+      return new NextResponse(html, {
+        headers: { "Content-Type": "text/html" }
+      });
+    });
+  };
+}
+
+export { createEmailsApi };

package/dist/src/core/server/interfaces/apis/emails/preview-email-api.js

@@ -0,0 +1,23 @@
+import { NextResponse } from 'next/server';
+
+function createPreviewEmailApi(ctx) {
+  const { infrastructure, interfaces } = ctx;
+  return function previewEmailApi(keys) {
+    return interfaces.executions.executeApi(async () => {
+      await infrastructure.cache.ipRateLimiter({
+        key: ["emails", ...keys],
+        maxAttempts: 60
+      });
+      await interfaces.middlewares.admin.adminAuthMiddleware.authenticate();
+      const html = await infrastructure.email.renderEmailTemplate(
+        keys.join("/")
+      );
+      if (!html) return new NextResponse("No Such Key");
+      return new NextResponse(html, {
+        headers: { "Content-Type": "text/html" }
+      });
+    });
+  };
+}
+
+export { createPreviewEmailApi };

package/dist/src/core/server/interfaces/apis/file-upload/file-upload-api.js

@@ -0,0 +1,40 @@
+import { NextResponse } from 'next/server';
+import { BodyParser } from 'next-body-parser';
+import 'mime-types';
+import { result } from '../../../../../shared/result/result.js';
+import 'clsx';
+import 'tailwind-merge';
+import { fileUploadValidator } from './validator.js';
+
+function createFileUploadApi(ctx) {
+  const { infrastructure, interfaces } = ctx;
+  return function fileUploadApi(request) {
+    return interfaces.executions.executeApi(async () => {
+      await infrastructure.cache.ipRateLimiter({
+        key: ["file-upload"],
+        maxAttempts: 60
+      });
+      await interfaces.middlewares.admin.adminAuthMiddleware.authenticate();
+      const payload = BodyParser.parse(await request.formData());
+      const { folderKey } = await fileUploadValidator(
+        infrastructure.zod.schemas
+      ).parseAsync(payload);
+      const blobFile = await infrastructure.zod.fileSchema().parseAsync(payload["blobFile"]);
+      const checksum = infrastructure.services.cryptoService.hash(
+        Buffer.from(await blobFile.arrayBuffer())
+      );
+      const resolvedFolderKey = payload["folder"] ? payload["folder"].key : folderKey;
+      const key = await infrastructure.services.storageService.upload({
+        blobFile,
+        ...resolvedFolderKey ? { folderKey: resolvedFolderKey } : {}
+      });
+      return NextResponse.json(
+        result.success({
+          data: { key, checksum }
+        })
+      );
+    });
+  };
+}
+
+export { createFileUploadApi };

package/dist/src/core/server/interfaces/apis/file-upload/validator.js

@@ -0,0 +1,15 @@
+const fileUploadValidator = (schemas) => schemas.z.object({
+  folder: schemas.z.object({ id: schemas.id().exist({ table: "folders", column: "id" }) }).optional(),
+  folderKey: schemas.key().exist({ table: "folders", column: "key" }).optional(),
+  //====== Translations ======
+  translations: schemas.array(
+    schemas.z.object({
+      locale: schemas.text(),
+      name: schemas.text().nullable(),
+      alt: schemas.text().nullable()
+    })
+  ).optional()
+  // Can be optional when use in Simple Upload
+});
+
+export { fileUploadValidator };

package/dist/src/core/server/interfaces/apis/health-check/health-check-api.js

@@ -0,0 +1,27 @@
+import { NextResponse } from 'next/server';
+import 'mime-types';
+import { result } from '../../../../../shared/result/result.js';
+import 'clsx';
+import 'tailwind-merge';
+
+function createHealthCheckApi(ctx) {
+  const { infrastructure, interfaces } = ctx;
+  return function healthCheckApi() {
+    return interfaces.executions.executeApi(async () => {
+      await infrastructure.cache.ipRateLimiter({
+        key: ["healthCheck"],
+        maxAttempts: 60
+      });
+      return NextResponse.json(
+        result.success({
+          data: {
+            status: "ok",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        })
+      );
+    });
+  };
+}
+
+export { createHealthCheckApi };