sitero 0.1.6 → 0.2.0

package/dist/src/core/server/infrastructure/cookie/cookie-service.js

@@ -1,81 +0,0 @@
-import { timingSafeEqual } from 'node:crypto';
-
-const DEFAULT_OPTIONS = {
-  httpOnly: true,
-  secure: process.env["NODE_ENV"] === "production",
-  sameSite: "strict",
-  path: "/"
-};
-function createCookieService(nextCookies, cryptoService, options = DEFAULT_OPTIONS) {
-  async function set({
-    name,
-    value,
-    expireSeconds
-  }) {
-    const cookieStore = await nextCookies();
-    cookieStore.set(name, value, { ...options, maxAge: expireSeconds });
-  }
-  async function setSignedCookie({
-    name,
-    value,
-    expireSeconds
-  }) {
-    const createdAt = Date.now();
-    const { signed } = cryptoService.sign({
-      value,
-      expireSeconds,
-      createdAt
-    });
-    await set({ name, value: signed, expireSeconds });
-  }
-  async function get({ name }) {
-    const cookieStore = await nextCookies();
-    const cookieValue = cookieStore.get(name)?.value;
-    return cookieValue;
-  }
-  async function getSignedCookie({ name }) {
-    const signed = await get({ name });
-    const value = verifySignedCookie({ signed });
-    return value;
-  }
-  function verifySignedCookie({ signed }) {
-    if (!signed) throw new Error("Invalid cookie");
-    const parts = signed.split("|");
-    if (parts.length !== 4) throw new Error("Invalid cookie");
-    const [value, expireSecondsStr, createdAtStr, signature] = parts;
-    const expireSeconds = Number.parseInt(expireSecondsStr, 10);
-    const createdAt = Number.parseInt(createdAtStr, 10);
-    if (Number.isNaN(expireSeconds) || Number.isNaN(createdAt)) {
-      throw new TypeError("Invalid cookie");
-    }
-    const now = Date.now();
-    if (now > createdAt + expireSeconds * 1e3) {
-      throw new Error("Cookie expired");
-    }
-    const { signature: generatedSignature } = cryptoService.sign({
-      value,
-      expireSeconds,
-      createdAt
-    });
-    const sig = Buffer.from(signature);
-    const gen = Buffer.from(generatedSignature);
-    if (sig.length !== gen.length || !timingSafeEqual(sig, gen)) {
-      throw new Error("Invalid cookie signature");
-    }
-    return value;
-  }
-  async function deleteCokkie({ name }) {
-    const cookieStore = await nextCookies();
-    cookieStore.delete(name);
-  }
-  return {
-    set,
-    setSignedCookie,
-    get,
-    getSignedCookie,
-    verifySignedCookie,
-    delete: deleteCokkie
-  };
-}
-
-export { createCookieService };

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

@@ -1,147 +0,0 @@
-import { createArgon2Service } from './argon2/argon2-service.js';
-import { createCache } from './cache/cache.js';
-import { createClearCache } from './cache/clear-cache.js';
-import { createCacheResult } from './cache/cache-result.js';
-import { createIpRateLimiter } from './cache/ip-rate-limiter.js';
-import { createCookieService } from './cookie/cookie-service.js';
-import { createCryptoService } from './crypto/crypto-service.js';
-import { createAdminCommandRepository } from './database/admin/command/admin-command-repository.js';
-import { createAdminQueryRepository } from './database/admin/query/admin-query-repository.js';
-import { createAdminRefreshTokenCommandRepository } from './database/admin-refresh-token/command/admin-refresh-token-command-repository.js';
-import { createAdminRefreshTokenQueryRepository } from './database/admin-refresh-token/query/admin-refresh-token-query-repository.js';
-import { createFileCommandRepository } from './database/file/command/file-command-repository.js';
-import { createFileQueryRepository } from './database/file/query/file-query-repository.js';
-import { createFolderCommandRepository } from './database/folder/command/folder-command-repository.js';
-import { createFolderQueryRepository } from './database/folder/query/folder-query-repository.js';
-import { createPostCommandRepository } from './database/post/command/post-command-repository.js';
-import { createPostQueryRepository } from './database/post/query/post-query-repository.js';
-import { createSeoMetadataCommandRepository } from './database/seo-metadata/command/seo-metadata-command-repository.js';
-import { createConfigCommandRepository } from './database/config/command/config-command-repository.js';
-import { createConfigQueryRepository } from './database/config/query/config-query-repository.js';
-import { createInquiryCommandRepository } from './database/inquiry/command/inquiry-command-repository.js';
-import { createInquiryQueryRepository } from './database/inquiry/query/inquiry-query-repository.js';
-import { createTransporter } from './email/transporter.js';
-import { createSendEmail } from './email/send-email.js';
-import { createRenderEmailTemplate } from './email/template/render-email-template.js';
-import { createServerIntorConfig } from './i18n/intor-config.js';
-import { createJwtService } from './jwt/jwt-service.js';
-import { createZod } from './zod/zod.js';
-import { createUnique } from './zod/rules/unique.js';
-import { createExist } from './zod/rules/exist.js';
-import { createSchemas } from './zod/schemas/schemas.js';
-import { createFileSchema, createMultiFileSchema } from './zod/schemas/file.js';
-import { createTocItemSchema } from './zod/schemas/toc-item.js';
-
-function createCoreInfrastructure(input) {
-  const { services, logger, prisma, next, constants } = input;
-  const serverIntorConfig = createServerIntorConfig({
-    appName: constants.appName,
-    webLocales: constants.webLocales,
-    messages: constants.messages
-  });
-  const argon2Service = createArgon2Service();
-  const cryptoService = createCryptoService({
-    secret: constants.secret
-  });
-  const jwtService = createJwtService({
-    secret: constants.secret,
-    appName: constants.appName
-  });
-  const cookieService = createCookieService(next.cookies, cryptoService);
-  const storageService = services.storage;
-  const cache = createCache({
-    appName: constants.appName,
-    redisUrl: constants.redisUrl
-  });
-  const clearCache = createClearCache(cache);
-  const cacheResult = createCacheResult(cache, logger);
-  const ipRateLimiter = createIpRateLimiter({
-    cache,
-    appName: constants.appName,
-    headers: next.headers,
-    serverIntorConfig
-  });
-  const transporter = createTransporter(constants.email.transporter);
-  const sendEmail = createSendEmail({
-    transporter,
-    logger
-  });
-  const renderEmailTemplate = createRenderEmailTemplate({
-    webUrl: constants.webUrl,
-    logoUrl: constants.email.logoUrl,
-    siteName: constants.email.siteName,
-    logger
-  });
-  const unique = createUnique(prisma);
-  const exist = createExist(prisma);
-  const z = createZod({ unique, exist });
-  const schemas = createSchemas({ z, exist });
-  const fileSchema = createFileSchema({
-    z,
-    maxSizeInMb: constants.maxFileSizeInMb
-  });
-  const multiFilesSchema = createMultiFileSchema({
-    z,
-    fileSchema,
-    maxSizeInMb: constants.maxFileSizeInMb
-  });
-  const tocItemSchema = createTocItemSchema({ z, schemas });
-  const repositories = {
-    adminQueryRepository: createAdminQueryRepository(prisma),
-    adminCommandRepository: createAdminCommandRepository(prisma),
-    adminRefreshTokenQueryRepository: createAdminRefreshTokenQueryRepository(prisma),
-    adminRefreshTokenCommandRepository: createAdminRefreshTokenCommandRepository(prisma),
-    folderQueryRepository: createFolderQueryRepository(prisma),
-    folderCommandRepository: createFolderCommandRepository(prisma),
-    fileQueryRepository: createFileQueryRepository(prisma),
-    fileCommandRepository: createFileCommandRepository(prisma),
-    postQueryRepository: createPostQueryRepository(prisma),
-    postCommandRepository: createPostCommandRepository(prisma),
-    seoMetadataCommandRepository: createSeoMetadataCommandRepository(prisma),
-    configCommandRepository: createConfigCommandRepository(prisma),
-    configQueryRepository: createConfigQueryRepository(prisma),
-    inquiryCommandRepository: createInquiryCommandRepository(prisma),
-    inquiryQueryRepository: createInquiryQueryRepository(prisma)
-  };
-  return {
-    // prisma (client)
-    prisma,
-    // services
-    services: {
-      argon2Service,
-      cryptoService,
-      jwtService,
-      cookieService,
-      storageService
-    },
-    // cache
-    cache: {
-      cache,
-      clearCache,
-      cacheResult,
-      ipRateLimiter
-    },
-    // email
-    email: {
-      transporter,
-      sendEmail,
-      renderEmailTemplate
-    },
-    // zod
-    zod: {
-      z,
-      schemas,
-      fileSchema,
-      multiFilesSchema,
-      tocItemSchema
-    },
-    // i18n
-    i18n: {
-      serverIntorConfig
-    },
-    // repositories
-    repositories
-  };
-}
-
-export { createCoreInfrastructure };

package/dist/src/core/server/infrastructure/crypto/crypto-service.js

@@ -1,64 +0,0 @@
-import crypto from 'node:crypto';
-
-function createCryptoService({ secret }) {
-  const SECRET = crypto.createHash("sha256").update(secret).digest();
-  const ALGORITHM = "aes-256-gcm";
-  const IV_LENGTH = 12;
-  function generateToken() {
-    return crypto.randomBytes(32).toString("base64url");
-  }
-  function hash(value) {
-    return crypto.createHash("sha256").update(value).digest("hex");
-  }
-  function hashBuffer(value) {
-    return crypto.createHash("sha256").update(value).digest();
-  }
-  function encrypt(data) {
-    const iv = crypto.randomBytes(IV_LENGTH);
-    const cipher = crypto.createCipheriv(ALGORITHM, SECRET, iv);
-    const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
-    const tag = cipher.getAuthTag();
-    return [
-      iv.toString("hex"),
-      encrypted.toString("hex"),
-      tag.toString("hex")
-    ].join(":");
-  }
-  function decrypt(data) {
-    const parts = data.split(":");
-    if (parts.length !== 3 || !parts.every(Boolean)) {
-      throw new Error("Invalid encrypted payload");
-    }
-    const [ivHex, encryptedHex, tagHex] = parts;
-    const iv = Buffer.from(ivHex, "hex");
-    const encrypted = Buffer.from(encryptedHex, "hex");
-    const tag = Buffer.from(tagHex, "hex");
-    const decipher = crypto.createDecipheriv(ALGORITHM, SECRET, iv);
-    decipher.setAuthTag(tag);
-    const decrypted = Buffer.concat([
-      decipher.update(encrypted),
-      decipher.final()
-    ]);
-    return decrypted.toString("utf8");
-  }
-  function sign({
-    value,
-    expireSeconds,
-    createdAt
-  }) {
-    const payload = `${value}|${expireSeconds}|${createdAt ?? Date.now()}`;
-    const signature = crypto.createHmac("sha256", SECRET).update(payload).digest("hex");
-    const signed = `${payload}|${signature}`;
-    return { signed, signature };
-  }
-  return {
-    generateToken,
-    hash,
-    hashBuffer,
-    encrypt,
-    decrypt,
-    sign
-  };
-}
-
-export { createCryptoService };

package/dist/src/core/server/infrastructure/database/admin/command/admin-command-repository.js

@@ -1,112 +0,0 @@
-import { OMIT_PASSWORD_HASH } from '../../constants.js';
-import { updateOne, connectOne } from '../../utils/connect.js';
-import { ADMIN_FULL_INCLUDE } from '../include.js';
-import { adminFullToDomain } from '../utils/admin-full-to-domain.js';
-
-function createAdminCommandRepository(prisma) {
-  async function create({
-    // core
-    role,
-    email,
-    passwordHash,
-    // better seo
-    socialLinks,
-    // ------------------------------------
-    // relations
-    // ------------------------------------
-    // File
-    avatarImage,
-    // ------------------------------------
-    // translation
-    // ------------------------------------
-    translations
-  }) {
-    const created = await prisma.admin.create({
-      data: {
-        // core
-        role,
-        email,
-        passwordHash,
-        // better seo
-        socialLinks,
-        // ------------------------------------------------------------------------
-        // relations
-        // ------------------------------------------------------------------------
-        // File
-        avatarImage: connectOne(avatarImage),
-        // ------------------------------------------------------------------------
-        // translation
-        // ------------------------------------------------------------------------
-        translations: { create: translations }
-      }
-    });
-    return created;
-  }
-  async function update({
-    id,
-    // core
-    role,
-    email,
-    // better seo
-    socialLinks,
-    // ------------------------------------
-    // relations
-    // ------------------------------------
-    // File
-    avatarImage,
-    // ------------------------------------
-    // translation
-    // ------------------------------------
-    translations,
-    // ------------------------------------
-    // timestamps
-    // ------------------------------------
-    emailVerifiedAt
-  }) {
-    const updated = await prisma.admin.update({
-      where: { id },
-      data: {
-        // core
-        role,
-        ...email !== void 0 ? { email } : {},
-        // better seo
-        socialLinks,
-        // ------------------------------------------------------------------------
-        // relations
-        // ------------------------------------------------------------------------
-        // File
-        avatarImage: updateOne(avatarImage),
-        // ------------------------------------------------------------------------
-        // translation
-        // ------------------------------------------------------------------------
-        translations: {
-          upsert: translations.map((t) => ({
-            where: { adminId_locale: { adminId: id, locale: t.locale } },
-            update: t,
-            create: t
-          }))
-        },
-        // ------------------------------------------------------------------------
-        // timestamps
-        // ------------------------------------------------------------------------
-        emailVerifiedAt
-      },
-      include: ADMIN_FULL_INCLUDE,
-      omit: OMIT_PASSWORD_HASH
-    });
-    return adminFullToDomain(updated);
-  }
-  async function _delete({ id }) {
-    const deleted = await prisma.admin.delete({
-      where: { id }
-    });
-    return deleted;
-  }
-  return {
-    create,
-    update,
-    delete: _delete
-  };
-}
-
-export { createAdminCommandRepository };

package/dist/src/core/server/infrastructure/database/admin/include.js

@@ -1,20 +0,0 @@
-const ADMIN_FULL_INCLUDE = {
-  // ---------------------------
-  // relations: AdminRefreshToken
-  // ---------------------------
-  adminRefreshTokens: true,
-  // ---------------------------
-  // relations: File
-  // ---------------------------
-  avatarImage: { include: { translations: true } },
-  // ---------------------------
-  // relations: Post
-  // ---------------------------
-  posts: true,
-  // ---------------------------
-  // translation
-  // ---------------------------
-  translations: true
-};
-
-export { ADMIN_FULL_INCLUDE };

package/dist/src/core/server/infrastructure/database/admin/query/admin-query-repository.js

@@ -1,97 +0,0 @@
-import { ADMIN_ROLES } from 'sitero-domain';
-import { OMIT_PASSWORD_HASH, ADMIN_ORDER_BY } from '../../constants.js';
-import { createPagination } from '../../utils/create-pagination.js';
-import { createSearch } from '../../utils/create-search.js';
-import { ADMIN_FULL_INCLUDE } from '../include.js';
-import { adminFullToDomain } from '../utils/admin-full-to-domain.js';
-
-function buildWhere(params) {
-  if (params.id) return { id: params.id };
-  if (params.email) return { email: params.email };
-  return;
-}
-function createAdminQueryRepository(prisma) {
-  async function findListCards({
-    locale,
-    // search
-    searchString,
-    currentRole: role,
-    adminIds,
-    // pagination
-    page,
-    pageSize
-  }) {
-    const where = {
-      // search
-      ...createSearch({
-        ...searchString !== void 0 ? { searchString } : {},
-        rootFields: ["email"],
-        locale,
-        translationFields: [
-          "name",
-          "authorName",
-          "description",
-          "jobTitle",
-          "url",
-          "worksFor",
-          "homeLocation",
-          "nationality"
-        ]
-      }),
-      // role
-      ...role !== ADMIN_ROLES.SUPER_ADMIN ? { role: { notIn: [ADMIN_ROLES.SUPER_ADMIN] } } : {},
-      // Specified ids
-      ...adminIds ? { id: { in: adminIds } } : {}
-    };
-    const [items, total] = await prisma.$transaction([
-      prisma.admin.findMany({
-        where,
-        orderBy: ADMIN_ORDER_BY,
-        include: ADMIN_FULL_INCLUDE,
-        ...createPagination(page, pageSize),
-        omit: OMIT_PASSWORD_HASH
-      }),
-      prisma.admin.count({ where })
-    ]);
-    return {
-      items: items.map(adminFullToDomain),
-      total
-    };
-  }
-  async function find(params) {
-    const where = buildWhere(params);
-    if (!where) return null;
-    const admin = await prisma.admin.findUnique({
-      where,
-      omit: OMIT_PASSWORD_HASH
-    });
-    if (!admin) return null;
-    return admin;
-  }
-  async function findFull(params) {
-    const where = buildWhere(params);
-    if (!where) return null;
-    const admin = await prisma.admin.findUnique({
-      where,
-      include: ADMIN_FULL_INCLUDE,
-      omit: OMIT_PASSWORD_HASH
-    });
-    if (!admin) return null;
-    return adminFullToDomain(admin);
-  }
-  async function findWithPasswordHash(params) {
-    const where = buildWhere(params);
-    if (!where) return null;
-    const admin = await prisma.admin.findUnique({ where });
-    if (!admin) return null;
-    return admin;
-  }
-  return {
-    findListCards,
-    find,
-    findFull,
-    findWithPasswordHash
-  };
-}
-
-export { createAdminQueryRepository };

package/dist/src/core/server/infrastructure/database/admin/utils/admin-full-to-domain.js

@@ -1,12 +0,0 @@
-import { adminRefreshTokenToDomain } from '../../admin-refresh-token/utils/admin-refresh-token-to-domain.js';
-import { postToDomain } from '../../post/utils/post-to-domain.js';
-
-function adminFullToDomain(admin) {
-  return {
-    ...admin,
-    adminRefreshTokens: admin.adminRefreshTokens.map(adminRefreshTokenToDomain),
-    posts: admin.posts.map(postToDomain)
-  };
-}
-
-export { adminFullToDomain };

package/dist/src/core/server/infrastructure/database/admin-refresh-token/command/admin-refresh-token-command-repository.js

@@ -1,46 +0,0 @@
-import { adminRefreshTokenToDomain } from '../utils/admin-refresh-token-to-domain.js';
-
-function createAdminRefreshTokenCommandRepository(prisma) {
-  async function create({
-    adminId,
-    ...params
-  }) {
-    const created = await prisma.adminRefreshToken.create({
-      data: {
-        ...params,
-        admin: { connect: { id: adminId } },
-        deviceInfo: params.deviceInfo
-      }
-    });
-    return adminRefreshTokenToDomain(created);
-  }
-  async function _delete({ id }) {
-    await prisma.adminRefreshToken.delete({ where: { id } });
-  }
-  async function deleteMany({
-    adminId,
-    excludeTokenHash
-  }) {
-    const { count } = await prisma.adminRefreshToken.deleteMany({
-      where: {
-        adminId,
-        ...excludeTokenHash ? { tokenHash: { not: excludeTokenHash } } : {}
-      }
-    });
-    return count;
-  }
-  async function deleteManyExpired() {
-    const { count } = await prisma.adminRefreshToken.deleteMany({
-      where: { expiresAt: { lt: /* @__PURE__ */ new Date() } }
-    });
-    return count;
-  }
-  return {
-    create,
-    delete: _delete,
-    deleteMany,
-    deleteManyExpired
-  };
-}
-
-export { createAdminRefreshTokenCommandRepository };

package/dist/src/core/server/infrastructure/database/admin-refresh-token/query/admin-refresh-token-query-repository.js

@@ -1,28 +0,0 @@
-import { adminRefreshTokenToDomain } from '../utils/admin-refresh-token-to-domain.js';
-
-function createAdminRefreshTokenQueryRepository(prisma) {
-  async function findManyByAdminId({
-    adminId
-  }) {
-    const adminRefreshTokens = await prisma.adminRefreshToken.findMany({
-      where: { adminId },
-      orderBy: [{ createdAt: "desc" }, { id: "asc" }]
-    });
-    return adminRefreshTokens.map(adminRefreshTokenToDomain);
-  }
-  async function findByToken({
-    tokenHash
-  }) {
-    const adminRefreshToken = await prisma.adminRefreshToken.findUnique({
-      where: { tokenHash }
-    });
-    if (!adminRefreshToken) return null;
-    return adminRefreshTokenToDomain(adminRefreshToken);
-  }
-  return {
-    findManyByAdminId,
-    findByToken
-  };
-}
-
-export { createAdminRefreshTokenQueryRepository };

package/dist/src/core/server/infrastructure/database/admin-refresh-token/utils/admin-refresh-token-to-domain.js

@@ -1,8 +0,0 @@
-function adminRefreshTokenToDomain(adminRefreshToken) {
-  return {
-    ...adminRefreshToken,
-    deviceInfo: adminRefreshToken.deviceInfo
-  };
-}
-
-export { adminRefreshTokenToDomain };