sitero 0.1.6 → 0.2.0

package/dist/src/core/infrastructure/prisma/post/post-prisma-ports.js

@@ -0,0 +1,283 @@
+import { ulid } from 'ulid';
+import { connectOrDisconnectOne, setMany, connectOne, connectMany } from '../helpers/relation-writes.js';
+import { createSearchWhere } from '../helpers/search-where.js';
+import { postToDomain } from './base-mappers.js';
+import { POST_DETAIL_INCLUDE, POST_LIST_CARD_INCLUDE, POST_REFERENCE_INCLUDE } from './include.js';
+import { postListCardToDomain, postDetailToDomain, postReferenceToDomain } from './mappers.js';
+
+const SEARCH_TEXT_FIELDS = [
+  "text1",
+  "text2",
+  "text3",
+  "text4",
+  "text5",
+  "text6",
+  "text7",
+  "text8",
+  "text9",
+  "text10"
+];
+const SEARCH_ROOT_FIELDS = [
+  "slug",
+  ...SEARCH_TEXT_FIELDS
+];
+const SEARCH_TRANSLATION_FIELDS = [
+  "title",
+  "subtitle",
+  "summary",
+  "description",
+  "content",
+  ...SEARCH_TEXT_FIELDS
+];
+const orderBy = [
+  { index: "asc" },
+  { updatedAt: "desc" },
+  { createdAt: "desc" },
+  { id: "asc" }
+];
+function reverseOrderBy(entry) {
+  const [item] = Object.entries(entry);
+  if (!item) return entry;
+  const [key, direction] = item;
+  return { [key]: direction === "asc" ? "desc" : "asc" };
+}
+const translationToWrite = (translation) => ({
+  ...translation,
+  externalLinks: translation.externalLinks,
+  faq: translation.faq,
+  toc: translation.toc
+});
+function createPostPrismaPorts(prisma) {
+  return {
+    // ------------------------------------------------------------
+    // Command
+    // ------------------------------------------------------------
+    postCommandPort: {
+      async create(input) {
+        const id = ulid();
+        const {
+          author,
+          topic,
+          parents,
+          tags,
+          relatedPosts,
+          coverImage,
+          contentImages,
+          files1,
+          files2,
+          file1,
+          file2,
+          file3,
+          file4,
+          translations,
+          slug,
+          ...scalars
+        } = input;
+        const authorWrite = connectOne(author);
+        const topicWrite = connectOne(topic);
+        const coverImageWrite = connectOne(coverImage);
+        const file1Write = connectOne(file1);
+        const file2Write = connectOne(file2);
+        const file3Write = connectOne(file3);
+        const file4Write = connectOne(file4);
+        const post = await prisma.post.create({
+          data: {
+            ...scalars,
+            id,
+            slug: slug?.trim() || id,
+            ...authorWrite ? { author: authorWrite } : {},
+            ...topicWrite ? { topic: topicWrite } : {},
+            parents: connectMany(parents),
+            tags: connectMany(tags),
+            relatedPosts: connectMany(relatedPosts),
+            ...coverImageWrite ? { coverImage: coverImageWrite } : {},
+            contentImages: connectMany(contentImages),
+            files1: connectMany(files1),
+            files2: connectMany(files2),
+            ...file1Write ? { file1: file1Write } : {},
+            ...file2Write ? { file2: file2Write } : {},
+            ...file3Write ? { file3: file3Write } : {},
+            ...file4Write ? { file4: file4Write } : {},
+            translations: { create: translations.map(translationToWrite) }
+          }
+        });
+        return postToDomain(post);
+      },
+      async update(input) {
+        const {
+          id,
+          author,
+          topic,
+          parents,
+          tags,
+          relatedPosts,
+          coverImage,
+          contentImages,
+          files1,
+          files2,
+          file1,
+          file2,
+          file3,
+          file4,
+          translations,
+          slug,
+          ...scalars
+        } = input;
+        const post = await prisma.post.update({
+          where: { id },
+          data: {
+            ...scalars,
+            slug: slug?.trim() || id,
+            author: connectOrDisconnectOne(author),
+            topic: connectOrDisconnectOne(topic),
+            parents: setMany(parents),
+            tags: setMany(tags),
+            relatedPosts: setMany(relatedPosts),
+            coverImage: connectOrDisconnectOne(coverImage),
+            contentImages: setMany(contentImages),
+            files1: setMany(files1),
+            files2: setMany(files2),
+            file1: connectOrDisconnectOne(file1),
+            file2: connectOrDisconnectOne(file2),
+            file3: connectOrDisconnectOne(file3),
+            file4: connectOrDisconnectOne(file4),
+            translations: {
+              upsert: translations.map((translation) => ({
+                where: {
+                  postId_locale: { postId: id, locale: translation.locale }
+                },
+                update: translationToWrite(translation),
+                create: translationToWrite(translation)
+              }))
+            }
+          }
+        });
+        return postToDomain(post);
+      },
+      async delete({ id }) {
+        return postToDomain(
+          await prisma.post.delete({ where: { id, isLocked: false } })
+        );
+      }
+    },
+    // ------------------------------------------------------------
+    // Query
+    // ------------------------------------------------------------
+    postQueryPort: {
+      async findMany(input) {
+        const posts = await prisma.post.findMany({
+          where: {
+            ...input?.type ? { type: input.type } : {},
+            ...input?.topicId === void 0 ? {} : { topicId: input.topicId },
+            ...input?.postIds ? { id: { in: input.postIds } } : {}
+          },
+          orderBy,
+          include: POST_REFERENCE_INCLUDE
+        });
+        return posts.map(postReferenceToDomain);
+      },
+      async findListCards(input) {
+        const customStateFilters = Object.fromEntries(
+          [
+            "state1",
+            "state2",
+            "state3",
+            "state4",
+            "state5",
+            "state6",
+            "state7",
+            "state8",
+            "state9",
+            "state10"
+          ].flatMap(
+            (key) => input[key] === void 0 ? [] : [[key, input[key]]]
+          )
+        );
+        const where = {
+          ...customStateFilters,
+          ...input.type ? { type: input.type } : {},
+          ...input.topicId === void 0 ? {} : { topicId: input.topicId },
+          ...input.topicSlug ? { topic: { slug: input.topicSlug } } : {},
+          ...input.parentId ? { parents: { some: { id: input.parentId } } } : {},
+          ...input.parentSlug ? { parents: { some: { slug: input.parentSlug } } } : {},
+          ...input.postIds || input.excludeIds ? {
+            id: {
+              ...input.postIds ? { in: input.postIds } : {},
+              ...input.excludeIds ? { notIn: input.excludeIds } : {}
+            }
+          } : {},
+          ...input.isActive === void 0 ? {} : { isActive: input.isActive },
+          ...input.isIndexActive === void 0 ? {} : { isIndexActive: input.isIndexActive },
+          ...input.isSlugActive === void 0 ? {} : { isSlugActive: input.isSlugActive },
+          ...input.isFeatured === void 0 ? {} : { isFeatured: input.isFeatured },
+          ...input.isShownOnHome === void 0 ? {} : { isShownOnHome: input.isShownOnHome },
+          ...createSearchWhere({
+            searchString: input.searchString,
+            rootFields: SEARCH_ROOT_FIELDS,
+            translation: {
+              locale: input.locale,
+              fields: SEARCH_TRANSLATION_FIELDS
+            }
+          })
+        };
+        const pagination = input.page && input.pageSize ? { skip: (input.page - 1) * input.pageSize, take: input.pageSize } : {};
+        const findManyInput = {
+          where,
+          orderBy,
+          include: POST_LIST_CARD_INCLUDE,
+          ...pagination
+        };
+        const result = await prisma.$transaction(async (transaction) => {
+          const [items, total] = await Promise.all([
+            transaction.post.findMany(findManyInput),
+            transaction.post.count({ where })
+          ]);
+          return { items, total };
+        });
+        return {
+          items: result.items.map(postListCardToDomain),
+          total: result.total
+        };
+      },
+      async findDetail(input) {
+        const lookup = "id" in input ? { id: input.id } : { type: input.type, slug: input.slug };
+        const scope = {
+          ...input.isActive === void 0 ? {} : { isActive: input.isActive },
+          ...input.topicSlug ? { topic: { slug: input.topicSlug } } : {}
+        };
+        const post = await prisma.post.findFirst({
+          where: { ...scope, ...lookup },
+          include: POST_DETAIL_INCLUDE
+        });
+        if (!post) return { post: null, previous: null, next: null };
+        const adjacentWhere = {
+          ...scope,
+          ..."id" in input ? {} : { type: input.type }
+        };
+        const [previous, next] = await Promise.all([
+          prisma.post.findFirst({
+            where: adjacentWhere,
+            orderBy: orderBy.map(reverseOrderBy),
+            cursor: { id: post.id },
+            skip: 1,
+            include: POST_LIST_CARD_INCLUDE
+          }),
+          prisma.post.findFirst({
+            where: adjacentWhere,
+            orderBy,
+            cursor: { id: post.id },
+            skip: 1,
+            include: POST_LIST_CARD_INCLUDE
+          })
+        ]);
+        return {
+          post: postDetailToDomain(post),
+          previous: previous ? postListCardToDomain(previous) : null,
+          next: next ? postListCardToDomain(next) : null
+        };
+      }
+    }
+  };
+}
+
+export { createPostPrismaPorts };

package/dist/src/core/infrastructure/prisma/seo-metadata/mappers.js

@@ -0,0 +1,16 @@
+function seoMetadataToWrite(data) {
+  return {
+    ...data,
+    alternate: data.alternate,
+    jsonLd: data.jsonLd
+  };
+}
+function seoMetadataToDomain(seoMetadata) {
+  return {
+    ...seoMetadata,
+    alternate: seoMetadata.alternate,
+    jsonLd: seoMetadata.jsonLd
+  };
+}
+
+export { seoMetadataToDomain, seoMetadataToWrite };

package/dist/src/core/infrastructure/prisma/seo-metadata/seo-metadata-prisma-ports.js

@@ -0,0 +1,26 @@
+import { seoMetadataToWrite, seoMetadataToDomain } from './mappers.js';
+
+function createSeoMetadataPrismaPorts(prisma) {
+  return {
+    // ------------------------------------------------------------
+    // Command
+    // ------------------------------------------------------------
+    seoMetadataCommandPort: {
+      async upsert({ postId, translations }) {
+        const seoMetadatas = await prisma.$transaction(
+          translations.map((translation) => {
+            const data = seoMetadataToWrite(translation);
+            return prisma.seoMetadata.upsert({
+              where: { postId_locale: { postId, locale: translation.locale } },
+              update: data,
+              create: { postId, ...data }
+            });
+          })
+        );
+        return seoMetadatas.map(seoMetadataToDomain);
+      }
+    }
+  };
+}
+
+export { createSeoMetadataPrismaPorts };

package/dist/src/core/infrastructure/rate-limiter/create-redis-rate-limiter-port.js

@@ -0,0 +1,72 @@
+const DEFAULT_LIMIT = 60;
+const DEFAULT_WINDOW_SECONDS = 60;
+const CONSUME_SCRIPT = `
+local current = redis.call("INCR", KEYS[1])
+
+if current == 1 then
+  redis.call("EXPIRE", KEYS[1], ARGV[2])
+end
+
+if current > tonumber(ARGV[1]) then
+  local ttl = redis.call("TTL", KEYS[1])
+  return {0, ttl}
+end
+
+return {1, 0}
+`;
+function normalizePositiveInteger(value, fallback) {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value)) return fallback;
+  const integer = Math.floor(value);
+  return integer > 0 ? integer : fallback;
+}
+function toNumber(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value !== "string") return void 0;
+  const number = Number(value);
+  return Number.isFinite(number) ? number : void 0;
+}
+function parseConsumeResult(result) {
+  if (!Array.isArray(result)) return { allowed: true };
+  const allowed = toNumber(result[0]) === 1;
+  if (allowed) return { allowed: true };
+  const retryAfterSeconds = toNumber(result[1]);
+  return retryAfterSeconds && retryAfterSeconds > 0 ? { allowed: false, retryAfterSeconds } : { allowed: false };
+}
+function createRedisRateLimiterPort(input) {
+  const {
+    getClient,
+    namespace,
+    defaultLimit = DEFAULT_LIMIT,
+    defaultWindowSeconds = DEFAULT_WINDOW_SECONDS,
+    logger
+  } = input;
+  return {
+    async consume(input2) {
+      const limit = normalizePositiveInteger(input2.limit, defaultLimit);
+      const windowSeconds = normalizePositiveInteger(
+        input2.windowSeconds,
+        defaultWindowSeconds
+      );
+      const key = [
+        namespace,
+        "rate-limit",
+        ...input2.key.map(encodeURIComponent)
+      ].join(":");
+      try {
+        const client = await getClient();
+        const result = await client.eval(CONSUME_SCRIPT, {
+          keys: [key],
+          arguments: [String(limit), String(windowSeconds)]
+        });
+        return parseConsumeResult(result);
+      } catch (error) {
+        logger?.error("Redis rate limiter error", { error, key });
+        return { allowed: true };
+      }
+    }
+  };
+}
+
+export { createRedisRateLimiterPort };

package/dist/src/core/infrastructure/redis/create-redis-client.js

@@ -0,0 +1,76 @@
+import { createClient } from 'redis';
+
+const CONNECT_WAIT_MS = 1e3;
+const COMMAND_TIMEOUT_MS = 1e3;
+function withDeadline(operation, milliseconds, onTimeout) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error("Redis operation timed out"));
+      onTimeout?.();
+    }, milliseconds);
+    operation.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(
+          error instanceof Error ? error : new Error("Redis operation failed", { cause: error })
+        );
+      }
+    );
+  });
+}
+function createRedisState(input) {
+  const { url, logger } = input;
+  const raw = createClient({
+    url,
+    socket: { connectTimeout: CONNECT_WAIT_MS },
+    disableOfflineQueue: true,
+    commandsQueueMaxLength: 1e3
+  });
+  raw.on("error", (error) => {
+    logger?.error("Redis client error", { error });
+  });
+  async function run(command) {
+    if (!raw.isReady) throw new Error("Redis client is not ready");
+    return withDeadline(command(), COMMAND_TIMEOUT_MS, () => {
+      if (raw.isOpen) raw.destroy();
+    });
+  }
+  return {
+    raw,
+    client: {
+      get isReady() {
+        return raw.isReady;
+      },
+      get: (key) => run(() => raw.get(key)),
+      set: (key, value, options) => run(() => raw.set(key, value, options)),
+      del: (keys) => run(() => raw.del(keys)),
+      sAdd: (key, members) => run(() => raw.sAdd(key, members)),
+      sMembers: (key) => run(() => raw.sMembers(key)),
+      expire: (key, seconds) => run(() => raw.expire(key, seconds)),
+      eval: (script, options) => run(() => raw.eval(script, options))
+    }
+  };
+}
+const globalForRedis = globalThis;
+async function getRedisClient(input) {
+  const { url } = input;
+  const states = globalForRedis.siteroRedisStates ??= /* @__PURE__ */ new Map();
+  const state = states.get(url) ?? createRedisState(input);
+  states.set(url, state);
+  if (state.raw.isReady) return state.client;
+  if (!state.connecting) {
+    if (state.raw.isOpen) throw new Error("Redis client is reconnecting");
+    state.connecting = state.raw.connect().then(() => void 0).finally(() => {
+      state.connecting = void 0;
+    });
+  }
+  await withDeadline(state.connecting, CONNECT_WAIT_MS);
+  if (!state.raw.isReady) throw new Error("Redis client is not ready");
+  return state.client;
+}
+
+export { getRedisClient };

package/dist/src/core/infrastructure/storage/object-storage/object-storage-service.js

@@ -0,0 +1,72 @@
+import { CopyObjectCommand, DeleteObjectCommand, PutObjectCommand } from '@aws-sdk/client-s3';
+import { createObjectKey } from '../utils.js';
+
+function createObjectStorageService({
+  client,
+  bucketName,
+  logger
+}) {
+  async function upload({ file }) {
+    const key = createObjectKey({
+      filename: file.name,
+      mimeType: file.type
+    });
+    try {
+      const buffer = Buffer.from(await file.arrayBuffer());
+      await client.send(
+        new PutObjectCommand({
+          Bucket: bucketName,
+          Key: key,
+          Body: buffer,
+          ContentType: file.type || void 0
+        })
+      );
+      logger.debug("Upload success", { key });
+      return key;
+    } catch (error) {
+      logger.error("Upload failed", { key, error });
+      throw error;
+    }
+  }
+  async function remove({ key }) {
+    try {
+      await client.send(
+        new DeleteObjectCommand({
+          Bucket: bucketName,
+          Key: key
+        })
+      );
+      logger.debug("Object removed", { key });
+    } catch (error) {
+      logger.error("Remove failed", { key, error });
+      throw error;
+    }
+  }
+  async function move({ fromKey, toKey }) {
+    if (fromKey === toKey) {
+      logger.debug("Move skipped (same key)", { key: fromKey });
+      return;
+    }
+    try {
+      await client.send(
+        new CopyObjectCommand({
+          Bucket: bucketName,
+          CopySource: `${bucketName}/${encodeURIComponent(fromKey)}`,
+          Key: toKey
+        })
+      );
+      await remove({ key: fromKey });
+      logger.debug("Object moved", { fromKey, toKey });
+    } catch (error) {
+      logger.error("Move failed", { fromKey, toKey, error });
+      throw error;
+    }
+  }
+  return {
+    upload,
+    remove,
+    move
+  };
+}
+
+export { createObjectStorageService };

package/dist/src/core/infrastructure/storage/sftp/sftp-service.js

@@ -0,0 +1,72 @@
+import path from 'node:path/posix';
+import { createObjectKey } from '../utils.js';
+
+function createSftpService({
+  sftpPool,
+  basePath,
+  logger
+}) {
+  async function upload({
+    file
+  }) {
+    const key = createObjectKey({
+      filename: file.name,
+      mimeType: file.type
+    });
+    const fullPath = path.join(basePath, key);
+    const client = await sftpPool.acquire();
+    try {
+      const buffer = Buffer.from(await file.arrayBuffer());
+      await client.put(buffer, fullPath);
+      logger.debug("SFTP upload success", { key });
+      return key;
+    } catch (error) {
+      logger.error("SFTP upload failed", { key, error });
+      throw error;
+    } finally {
+      await sftpPool.release(client);
+    }
+  }
+  async function remove({ key }) {
+    const fullPath = path.join(basePath, key);
+    const client = await sftpPool.acquire();
+    try {
+      await client.delete(fullPath);
+      logger.debug("SFTP object removed", { key });
+    } catch (error) {
+      if (error instanceof Error && /no such file/i.test(error.message)) {
+        logger.debug("SFTP remove skipped (not found)", { key });
+        return;
+      }
+      logger.error("SFTP remove failed", { key, error });
+      throw error;
+    } finally {
+      await sftpPool.release(client);
+    }
+  }
+  async function move({ fromKey, toKey }) {
+    if (fromKey === toKey) {
+      logger.debug("SFTP move skipped (same key)", { key: fromKey });
+      return;
+    }
+    const fromPath = path.join(basePath, fromKey);
+    const toPath = path.join(basePath, toKey);
+    const client = await sftpPool.acquire();
+    try {
+      await client.rename(fromPath, toPath);
+      logger.debug("SFTP object moved", { fromKey, toKey });
+    } catch (error) {
+      logger.error("SFTP move failed", { fromKey, toKey, error });
+      throw error;
+    } finally {
+      await sftpPool.release(client);
+    }
+  }
+  return {
+    upload,
+    remove,
+    move
+  };
+}
+
+export { createSftpService };

package/dist/src/core/infrastructure/storage/utils.js

@@ -0,0 +1,25 @@
+import path from 'node:path/posix';
+import { ulid } from 'ulid';
+import { mimeToExtension } from '../../../shared/blob-file/mime-to-extension.js';
+import 'mime-types';
+import 'sitero-domain';
+import 'react';
+import 'ua-parser-js';
+import '../../../shared/client/react-query/client.js';
+import 'react/jsx-runtime';
+import '@tanstack/react-query';
+import 'clsx';
+import 'tailwind-merge';
+import 'zod';
+
+function createObjectKey({
+  filename,
+  mimeType
+}) {
+  const extensionFromFilename = path.extname(filename ?? "").toLowerCase();
+  const extensionFromMime = !extensionFromFilename && mimeType ? `.${mimeToExtension(mimeType)}` : "";
+  const extension = extensionFromFilename || extensionFromMime;
+  return ulid() + extension;
+}
+
+export { createObjectKey };

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

@@ -0,0 +1,51 @@
+import argon2 from 'argon2';
+
+async function hash(password) {
+  return await argon2.hash(password, {
+    type: argon2.argon2id,
+    memoryCost: 19456,
+    // ~19MB
+    timeCost: 2,
+    parallelism: 1
+  });
+}
+function adminSeeder({
+  prisma,
+  admins,
+  locales
+}) {
+  async function checkExistence(email) {
+    const admin = await prisma.admin.findUnique({
+      where: { email },
+      select: { id: true }
+    });
+    return admin ? true : false;
+  }
+  async function seed() {
+    const preferredLocale = locales[0];
+    if (!preferredLocale) throw new Error("Admin seeding requires a locale");
+    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,
+          preferredLocale,
+          emailVerifiedAt: /* @__PURE__ */ new Date(),
+          // translation
+          translations: {
+            create: locales.map((locale) => ({
+              locale,
+              name: admin.name[locale]
+            }))
+          }
+        }
+      });
+    }
+  }
+  return { seed };
+}
+
+export { adminSeeder };