sitero 0.0.1

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

@@ -0,0 +1,59 @@
+import { NextResponse } from 'next/server';
+import { BodyParser } from 'next-body-parser';
+import pLimit from 'p-limit';
+import 'mime-types';
+import { result } from '../../../../../shared/result/result.js';
+import 'clsx';
+import 'tailwind-merge';
+import { multiFilesUploadValidator } from './validator.js';
+
+function createMultiFilesUploadApi(ctx) {
+  const { infrastructure, interfaces } = ctx;
+  return function multiFilesUploadApi(request) {
+    return interfaces.executions.executeApi(async () => {
+      await infrastructure.cache.ipRateLimiter({
+        key: ["multi-files-upload"],
+        maxAttempts: 60,
+        timeWindow: 60
+      });
+      await interfaces.middlewares.admin.adminAuthMiddleware.authenticate();
+      const payload = BodyParser.parse(await request.formData());
+      const { folderKey, blobFileInfos } = await multiFilesUploadValidator(
+        infrastructure.zod.schemas
+      ).parseAsync(payload);
+      const blobFiles = await infrastructure.zod.multiFilesSchema().parseAsync(payload["blobFiles"]);
+      const limit = pLimit(5);
+      const uploadResults = await Promise.all(
+        blobFiles.map(
+          (blobFile, index) => limit(async () => {
+            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 } : {}
+            });
+            const { name, size, type } = blobFile;
+            const { width, height, duration } = blobFileInfos[index] ?? {};
+            return {
+              checksum,
+              key,
+              fileMeta: { name, size, type },
+              width: width ?? null,
+              height: height ?? null,
+              duration: duration ?? null
+            };
+          })
+        )
+      );
+      return NextResponse.json(
+        result.success({
+          data: { uploadResults }
+        })
+      );
+    });
+  };
+}
+
+export { createMultiFilesUploadApi };

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

@@ -0,0 +1,13 @@
+const multiFilesUploadValidator = (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(),
+  blobFileInfos: schemas.array(
+    schemas.z.object({
+      width: schemas.positiveInteger().nullable(),
+      height: schemas.positiveInteger().nullable(),
+      duration: schemas.positiveNumber().nullable()
+    })
+  )
+});
+
+export { multiFilesUploadValidator };

package/dist/src/core/server/interfaces/create-core-interfaces.js

@@ -0,0 +1,87 @@
+import { createAdminSignInAction } from './actions/admin/sign-in/sign-in-action.js';
+import { createAdminSignOutAction } from './actions/admin/sign-out/sign-out-action.js';
+import { createAdminVerifyAction } from './actions/admin/verify/verify-action.js';
+import { createAdminChangePasswordAction } from './actions/admin/change-password/change-password-action.js';
+import { createAdminVerifyEmailAction } from './actions/admin/verify-email/verify-email-action.js';
+import { createAdminEmailUnverifiedAction } from './actions/admin/email-unverifired/email-unverifired-action.js';
+import { createAdminForgotPasswordAction } from './actions/admin/forgot-password/forgot-password-action.js';
+import { createAdminResetPasswordAction } from './actions/admin/reset-password/reset-password-action.js';
+import { createHealthCheckApi } from './apis/health-check/health-check-api.js';
+import { createFileUploadApi } from './apis/file-upload/file-upload-api.js';
+import { createMultiFilesUploadApi } from './apis/multi-files-upload/multi-files-upload-api.js';
+import { createEmailsApi } from './apis/emails/emails-api.js';
+import { createPreviewEmailApi } from './apis/emails/preview-email-api.js';
+import { createExecuteAction } from './execution/execute-action.js';
+import { createExecuteApi } from './execution/execute-api.js';
+import { createRunAction } from './execution/run-action.js';
+import { createInitI18n } from './execution/init-i18n.js';
+import { createAdminAuthMiddleware } from './middlewares/admin/auth-middleware.js';
+import { createUserAuthMiddleware } from './middlewares/user/auth-middleware.js';
+
+function createCoreInterfaces(input) {
+  const { infrastructure, applications, next, constants } = input;
+  const executionContext = {
+    infrastructure,
+    logger: input.logger,
+    constants: input.constants
+  };
+  const initI18n = createInitI18n(executionContext);
+  const executeAction = createExecuteAction({ initI18n, ...executionContext });
+  const executeApi = createExecuteApi({ initI18n, ...executionContext });
+  const runAction = createRunAction(executionContext);
+  const executions = {
+    executeAction,
+    executeApi,
+    runAction
+  };
+  const middlewareContext = {
+    infrastructure,
+    applications,
+    next,
+    constants
+  };
+  const adminAuthMiddleware = createAdminAuthMiddleware(middlewareContext);
+  const userAuthMiddleware = createUserAuthMiddleware(middlewareContext);
+  const middlewares = {
+    admin: { adminAuthMiddleware },
+    user: { userAuthMiddleware }
+  };
+  const apiContext = {
+    infrastructure,
+    interfaces: { executions, middlewares }
+  };
+  const apis = {
+    healthCheck: createHealthCheckApi(apiContext),
+    fileUpload: createFileUploadApi(apiContext),
+    multiFilesUpload: createMultiFilesUploadApi(apiContext),
+    emails: createEmailsApi(apiContext),
+    previewEmail: createPreviewEmailApi(apiContext)
+  };
+  const actionContext = {
+    infrastructure,
+    applications,
+    interfaces: { executions, middlewares },
+    next,
+    constants
+  };
+  const actions = {
+    admin: {
+      signIn: createAdminSignInAction(actionContext),
+      signOut: createAdminSignOutAction(actionContext),
+      verify: createAdminVerifyAction(actionContext),
+      changePassword: createAdminChangePasswordAction(actionContext),
+      verifyEmail: createAdminVerifyEmailAction(actionContext),
+      emailUnverified: createAdminEmailUnverifiedAction(actionContext),
+      forgotPassword: createAdminForgotPasswordAction(actionContext),
+      resetPassword: createAdminResetPasswordAction(actionContext)
+    }
+  };
+  return {
+    executions,
+    middlewares,
+    apis,
+    actions
+  };
+}
+
+export { createCoreInterfaces };

package/dist/src/core/server/interfaces/execution/execute-action.js

@@ -0,0 +1,40 @@
+import 'mime-types';
+import { result } from '../../../../shared/result/result.js';
+import 'clsx';
+import 'tailwind-merge';
+import { normalizeError } from './normalize-error.js';
+
+function createExecuteAction({
+  initI18n,
+  ...ctx
+}) {
+  const { infrastructure, logger } = ctx;
+  return async function executeAction(fn, options = {}) {
+    const translator = await initI18n();
+    const withCache = options.type === "query" && options.key;
+    try {
+      const { data, i18nKey, message, meta } = withCache ? await infrastructure.cache.cacheResult({
+        key: options.key,
+        ...options.ttl ? { ttl: options.ttl } : {},
+        load: async () => fn(translator),
+        isList: options.isList
+      }) : await fn(translator);
+      if (options.type === "command") await infrastructure.cache.cache.clear();
+      const finalMessage = i18nKey ? translator.t(i18nKey) : message;
+      return result.success({
+        ...finalMessage ? { message: finalMessage } : {},
+        ...data !== void 0 ? { data } : {},
+        ...meta ? { meta } : {}
+      });
+    } catch (error) {
+      const { message, errors, isInternal } = normalizeError(error, translator);
+      logger.error({ message, errors });
+      return result.error({
+        message: isInternal ? "Internal server error" : message,
+        ...errors !== void 0 ? { errors } : {}
+      });
+    }
+  };
+}
+
+export { createExecuteAction };

package/dist/src/core/server/interfaces/execution/execute-api.js

@@ -0,0 +1,34 @@
+import { NextResponse } from 'next/server';
+import 'mime-types';
+import { result } from '../../../../shared/result/result.js';
+import 'clsx';
+import 'tailwind-merge';
+import { normalizeError } from './normalize-error.js';
+
+function createExecuteApi({
+  initI18n,
+  ...ctx
+}) {
+  const { logger } = ctx;
+  return async function serverApi(fn) {
+    const translator = await initI18n();
+    try {
+      return await fn(translator);
+    } catch (error) {
+      const { message, errors, statusCode, isInternal } = normalizeError(
+        error,
+        translator
+      );
+      logger.error({ message, errors });
+      return NextResponse.json(
+        result.error({
+          message: isInternal ? "Internal server error" : message,
+          ...errors ? { errors } : {}
+        }),
+        { status: statusCode }
+      );
+    }
+  };
+}
+
+export { createExecuteApi };

package/dist/src/core/server/interfaces/execution/init-i18n.js

@@ -0,0 +1,32 @@
+import { getTranslator } from 'intor/next/server';
+import { CMS_DEFAULT_LOCALE } from '../../../../constants/cms-locale.js';
+
+function getZodLocaleFactory(z, locale) {
+  const localeKey = locale.replace(
+    /[-_]+([a-zA-Z])/g,
+    (_, char) => char.toUpperCase()
+  );
+  const languageKey = locale.split(/[-_]/)[0]?.toLowerCase();
+  for (const key of [localeKey, languageKey]) {
+    const zodLocale = key ? z.locales[key] : void 0;
+    if (typeof zodLocale === "function") return zodLocale;
+  }
+  return;
+}
+function createInitI18n(ctx) {
+  const {
+    infrastructure: { zod, i18n }
+  } = ctx;
+  return async function initI18n() {
+    const translator = await getTranslator(
+      i18n.intorConfig
+    );
+    const zodLocaleFactory = getZodLocaleFactory(zod.z, translator.locale) ?? getZodLocaleFactory(zod.z, CMS_DEFAULT_LOCALE);
+    if (zodLocaleFactory) {
+      zod.z.config(zodLocaleFactory());
+    }
+    return translator;
+  };
+}
+
+export { createInitI18n };

package/dist/src/core/server/interfaces/execution/normalize-error.js

@@ -0,0 +1,35 @@
+import { ZodError } from 'zod';
+import { ServerError } from '../../server-error.js';
+
+const normalizeError = (error, translator) => {
+  if (error instanceof ZodError) {
+    const errors = error.issues.map((issue) => {
+      let message = issue.message;
+      if (issue.code === "custom" && issue.params?.["i18nKey"]) {
+        message = translator.t(
+          issue.params["i18nKey"]
+        );
+      }
+      return {
+        field: issue.path.join("."),
+        // e.path: string[]  e.g. ["name", "email"]
+        message,
+        code: issue.code
+      };
+    });
+    return { message: "Validation faild", errors, statusCode: 422 };
+  }
+  if (error instanceof ServerError) {
+    const message = translator.t(
+      error.i18nKey ?? "error.internal-server-error"
+    );
+    return { message, statusCode: error.statusCode ?? 500 };
+  }
+  return {
+    message: error instanceof Error ? error.message : JSON.stringify(error),
+    statusCode: 500,
+    isInternal: true
+  };
+};
+
+export { normalizeError };

package/dist/src/core/server/interfaces/execution/run-action.js

@@ -0,0 +1,27 @@
+function createRunAction(ctx) {
+  const { logger } = ctx;
+  return async function runAction(action, options) {
+    const { shouldRun, onSuccess, onError } = options || {};
+    if (shouldRun) {
+      const shouldProceed = await shouldRun();
+      if (shouldProceed === false) {
+        return {};
+      }
+    }
+    try {
+      const response = await action();
+      if (response.success) {
+        const data = response.data ?? {};
+        onSuccess?.(data);
+        return data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      logger.error({ error });
+      onError?.(error);
+      return {};
+    }
+  };
+}
+
+export { createRunAction };

package/dist/src/core/server/interfaces/middlewares/admin/auth-middleware.js

@@ -0,0 +1,30 @@
+import { ServerError } from '../../../server-error.js';
+import { adminVerifyAccessToken } from './verify-access-token.js';
+import { adminVerifyRefreshToken } from './verify-refresh-token.js';
+
+function createAdminAuthMiddleware(ctx) {
+  const { infrastructure, applications, next } = ctx;
+  const adminAuthMiddleware = {
+    async authenticate() {
+      const verifiedAccessToken = await adminVerifyAccessToken(ctx);
+      if (verifiedAccessToken) return verifiedAccessToken.admin;
+      const verifiedRefreshToken = await adminVerifyRefreshToken(ctx);
+      if (!verifiedRefreshToken) throw ServerError.unauthorized();
+      const { adminRefreshToken, admin } = verifiedRefreshToken;
+      await infrastructure.repositories.adminRefreshTokenCommandRepository.delete(
+        {
+          id: adminRefreshToken.id
+        }
+      );
+      await applications.useCases.adminAuthUseCases.refreshTokens({
+        admin,
+        deviceInfo: adminRefreshToken.deviceInfo,
+        ip: (await next.headers()).get("x-forwarded-for") || "unknown"
+      });
+      return admin;
+    }
+  };
+  return adminAuthMiddleware;
+}
+
+export { createAdminAuthMiddleware };

package/dist/src/core/server/interfaces/middlewares/admin/verify-access-token.js

@@ -0,0 +1,22 @@
+async function adminVerifyAccessToken(ctx) {
+  const { infrastructure, constants } = ctx;
+  try {
+    const token = await infrastructure.services.cookieService.getSignedCookie({
+      name: constants.accessTokenName
+    });
+    const payload = infrastructure.services.jwtService.verify({
+      token,
+      secret: infrastructure.services.cryptoService.hash(
+        constants.accessTokenSecret
+      )
+    });
+    const admin = await infrastructure.repositories.adminQueryRepository.findFull({
+      id: payload["id"]
+    });
+    return admin ? { admin } : null;
+  } catch {
+    return null;
+  }
+}
+
+export { adminVerifyAccessToken };

package/dist/src/core/server/interfaces/middlewares/admin/verify-refresh-token.js

@@ -0,0 +1,20 @@
+async function adminVerifyRefreshToken(ctx) {
+  const { infrastructure, constants } = ctx;
+  try {
+    const token = await infrastructure.services.cookieService.getSignedCookie({
+      name: constants.refreshTokenName
+    });
+    const adminRefreshToken = await infrastructure.repositories.adminRefreshTokenQueryRepository.findByToken(
+      { tokenHash: infrastructure.services.cryptoService.hash(token) }
+    );
+    if (!adminRefreshToken) return null;
+    const admin = await infrastructure.repositories.adminQueryRepository.findFull({
+      id: adminRefreshToken.adminId
+    });
+    return admin ? { adminRefreshToken, admin } : null;
+  } catch {
+    return null;
+  }
+}
+
+export { adminVerifyRefreshToken };

package/dist/src/core/server/interfaces/middlewares/user/auth-middleware.js

@@ -0,0 +1,30 @@
+import { ServerError } from '../../../server-error.js';
+import { userVerifyAccessToken } from './verify-access-token.js';
+import { userVerifyRefreshToken } from './verify-refresh-token.js';
+
+function createUserAuthMiddleware(ctx) {
+  const { infrastructure, applications, next } = ctx;
+  const userAuthMiddleware = {
+    async authenticate() {
+      const verifiedAccessToken = await userVerifyAccessToken(ctx);
+      if (verifiedAccessToken) return verifiedAccessToken.user;
+      const verifiedRefreshToken = await userVerifyRefreshToken(ctx);
+      if (!verifiedRefreshToken) throw ServerError.unauthorized();
+      const { userRefreshToken, user } = verifiedRefreshToken;
+      await infrastructure.repositories.userRefreshTokenCommandRepository.delete(
+        {
+          id: userRefreshToken.id
+        }
+      );
+      await applications.useCases.userAuthUseCases.refreshTokens({
+        user,
+        deviceInfo: userRefreshToken.deviceInfo,
+        ip: (await next.headers()).get("x-forwarded-for") || "unknown"
+      });
+      return user;
+    }
+  };
+  return userAuthMiddleware;
+}
+
+export { createUserAuthMiddleware };

package/dist/src/core/server/interfaces/middlewares/user/verify-access-token.js

@@ -0,0 +1,24 @@
+async function userVerifyAccessToken(ctx) {
+  const { infrastructure, constants } = ctx;
+  try {
+    const token = await infrastructure.services.cookieService.getSignedCookie({
+      name: constants.accessTokenName
+    });
+    const payload = infrastructure.services.jwtService.verify({
+      token,
+      secret: infrastructure.services.cryptoService.hash(
+        constants.accessTokenSecret
+      )
+    });
+    const user = await infrastructure.repositories.userQueryRepository.findFull(
+      {
+        id: payload["id"]
+      }
+    );
+    return user ? { user } : null;
+  } catch {
+    return null;
+  }
+}
+
+export { userVerifyAccessToken };

package/dist/src/core/server/interfaces/middlewares/user/verify-refresh-token.js

@@ -0,0 +1,22 @@
+async function userVerifyRefreshToken(ctx) {
+  const { infrastructure, constants } = ctx;
+  try {
+    const token = await infrastructure.services.cookieService.getSignedCookie({
+      name: constants.refreshTokenName
+    });
+    const userRefreshToken = await infrastructure.repositories.userRefreshTokenQueryRepository.findByToken(
+      { tokenHash: infrastructure.services.cryptoService.hash(token) }
+    );
+    if (!userRefreshToken) return null;
+    const user = await infrastructure.repositories.userQueryRepository.findFull(
+      {
+        id: userRefreshToken.userId
+      }
+    );
+    return user ? { userRefreshToken, user } : null;
+  } catch {
+    return null;
+  }
+}
+
+export { userVerifyRefreshToken };

package/dist/src/core/server/seeders/admin/seeder.js

@@ -0,0 +1,49 @@
+import argon2 from 'argon2';
+
+const DEFAULT_OPTIONS = {
+  type: argon2.argon2id,
+  memoryCost: 19456,
+  // ~19MB
+  timeCost: 2,
+  parallelism: 1
+};
+async function hash(password) {
+  return await argon2.hash(password, DEFAULT_OPTIONS);
+}
+function adminSeeder({
+  prisma,
+  admins,
+  locales
+}) {
+  async function checkExistence(email) {
+    const found = await prisma.admin.findUnique({
+      where: { email },
+      select: { id: true }
+    });
+    return found ? true : false;
+  }
+  async function seed() {
+    for (const admin of Object.values(admins)) {
+      const exists = await checkExistence(admin.email);
+      if (exists) continue;
+      await prisma.admin.create({
+        data: {
+          email: admin.email,
+          passwordHash: await hash(admin.password),
+          role: admin.role,
+          emailVerifiedAt: /* @__PURE__ */ new Date(),
+          // translation
+          translations: {
+            create: locales.map((locale) => ({
+              locale,
+              name: admin.name[locale]
+            }))
+          }
+        }
+      });
+    }
+  }
+  return { seed };
+}
+
+export { adminSeeder };

package/dist/src/core/server/seeders/config/seeder.js

@@ -0,0 +1,61 @@
+function configSeeder({
+  prisma,
+  configs: staticConfigs,
+  locales
+}) {
+  async function checkExistence(slug) {
+    const found = await prisma.config.findUnique({
+      where: { slug },
+      select: { id: true }
+    });
+    return found ? true : false;
+  }
+  async function seed() {
+    const configs = Object.entries(staticConfigs).map(([slug, data]) => ({
+      slug,
+      ...data
+    }));
+    for (const [i, item] of configs.entries()) {
+      const exists = await checkExistence(item.slug);
+      if (exists) continue;
+      await prisma.config.create({
+        data: {
+          slug: item.slug,
+          index: i + 1,
+          translations: {
+            create: locales.map((locale) => {
+              return {
+                locale,
+                // text
+                text1: null,
+                text2: null,
+                text3: null,
+                text4: null,
+                text5: null,
+                text6: null,
+                text7: null,
+                text8: null,
+                text9: null,
+                text10: null,
+                // json array
+                data1: [],
+                data2: [],
+                data3: [],
+                data4: [],
+                data5: [],
+                data6: [],
+                data7: [],
+                data8: [],
+                data9: [],
+                data10: []
+              };
+            })
+          }
+        }
+      });
+    }
+  }
+  return { seed };
+}
+
+export { configSeeder };

package/dist/src/core/server/seeders/folder/seeder.js

@@ -0,0 +1,26 @@
+import '../../../domain/resources/admin/constants.js';
+import { SIMPLE_UPLOAD_FOLDER_NAME, SIMPLE_UPLOAD_FOLDER_KEY } from '../../../domain/resources/constants.js';
+
+function folderSeeder({ prisma }) {
+  async function checkExistence() {
+    const found = await prisma.folder.findUnique({
+      where: { key: SIMPLE_UPLOAD_FOLDER_KEY },
+      select: { id: true }
+    });
+    return found ? true : false;
+  }
+  async function seed() {
+    const exists = await checkExistence();
+    if (exists) return;
+    await prisma.folder.create({
+      data: {
+        key: SIMPLE_UPLOAD_FOLDER_KEY,
+        isLocked: true,
+        name: SIMPLE_UPLOAD_FOLDER_NAME
+      }
+    });
+  }
+  return { seed };
+}
+
+export { folderSeeder };

package/dist/src/core/server/seeders/page/seeder.js

@@ -0,0 +1,47 @@
+import '../../../domain/resources/admin/constants.js';
+import { POST_TYPES } from '../../../domain/resources/post/props.js';
+
+function pageSeeder({
+  prisma,
+  pages: staticPages,
+  locales
+}) {
+  async function checkExistence(slug) {
+    const found = await prisma.post.findFirst({
+      where: { type: POST_TYPES.PAGE, slug },
+      select: { id: true }
+    });
+    return found ? true : false;
+  }
+  async function seed() {
+    const pages = Object.entries(staticPages).map(([slug, data]) => ({
+      slug,
+      ...data
+    }));
+    for (const [i, item] of pages.entries()) {
+      const exists = await checkExistence(item.slug);
+      if (exists) continue;
+      await prisma.post.create({
+        data: {
+          type: POST_TYPES.PAGE,
+          // states
+          isActive: true,
+          isSlugActive: true,
+          slug: item.slug,
+          isIndexActive: true,
+          index: i + 1,
+          // translation
+          translations: {
+            create: locales.map((locale) => ({
+              locale,
+              title: item.title[locale]
+            }))
+          }
+        }
+      });
+    }
+  }
+  return { seed };
+}
+
+export { pageSeeder };