sitero 0.1.6 → 0.2.0

package/dist/src/core/seeders/seed.js

@@ -0,0 +1,21 @@
+import { adminSeeder } from './admin/seeder.js';
+import { configSeeder } from './config/seeder.js';
+import { pageSeeder } from './page/seeder.js';
+import { topicSeeder } from './topic/seeder.js';
+
+async function seed({
+  prisma,
+  webLocales: locales,
+  admins,
+  pages,
+  topics,
+  configs
+}) {
+  const siteroPrisma = prisma;
+  await adminSeeder({ prisma: siteroPrisma, locales, admins }).seed();
+  await pageSeeder({ prisma: siteroPrisma, locales, pages }).seed();
+  await topicSeeder({ prisma: siteroPrisma, locales, topics }).seed();
+  await configSeeder({ prisma: siteroPrisma, locales, configs }).seed();
+}
+
+export { seed };

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

@@ -0,0 +1,124 @@
+import { createSiteroServer as createSiteroServer$1 } from 'sitero-server';
+import { createAuthenticationPasswordPort } from '../infrastructure/authentication/authentication-password-port.js';
+import { createAuthenticationTokenPort } from '../infrastructure/authentication/authentication-token-port.js';
+import { createRedisCachePort } from '../infrastructure/cache/create-redis-cache-port.js';
+import { createConfigPrismaPorts } from '../infrastructure/prisma/config/config-prisma-ports.js';
+import { createAdminPrismaPorts } from '../infrastructure/prisma/admin/admin-prisma-ports.js';
+import { createAdminAuthenticationPrismaPort } from '../infrastructure/prisma/authentication/admin/admin-authentication-prisma-port.js';
+import { createAdminRefreshTokenPrismaPorts } from '../infrastructure/prisma/admin-refresh-token/admin-refresh-token-prisma-ports.js';
+import { createFilePrismaPorts } from '../infrastructure/prisma/file/file-prisma-ports.js';
+import { createInquiryPrismaPorts } from '../infrastructure/prisma/inquiry/inquiry-prisma-ports.js';
+import { createPostPrismaPorts } from '../infrastructure/prisma/post/post-prisma-ports.js';
+import { createSeoMetadataPrismaPorts } from '../infrastructure/prisma/seo-metadata/seo-metadata-prisma-ports.js';
+import { createRedisRateLimiterPort } from '../infrastructure/rate-limiter/create-redis-rate-limiter-port.js';
+import { getRedisClient } from '../infrastructure/redis/create-redis-client.js';
+import { createEmailComposition } from './email.js';
+import { createRateLimits } from './rate-limits.js';
+
+function createSiteroServer(input) {
+  const {
+    appName,
+    appSecret,
+    cacheTtlSeconds,
+    logger,
+    namespace = appName,
+    redisUrl,
+    storage,
+    uploads,
+    policies,
+    email
+  } = input;
+  const authenticationToken = createAuthenticationTokenPort({
+    appName,
+    secret: appSecret
+  });
+  const cache = createRedisCachePort({
+    getClient: () => getRedisClient({ url: redisUrl, logger }),
+    namespace,
+    ttlSeconds: cacheTtlSeconds
+  });
+  const rateLimiter = createRedisRateLimiterPort({
+    getClient: () => getRedisClient({ url: redisUrl, logger }),
+    namespace,
+    logger,
+    ...input.kernel?.rateLimiter
+  });
+  const emailComposition = createEmailComposition({
+    email,
+    logger,
+    authenticationToken
+  });
+  const prisma = input.prisma;
+  const adminPrismaPorts = createAdminPrismaPorts(prisma);
+  const adminRefreshTokenPrismaPorts = createAdminRefreshTokenPrismaPorts(prisma);
+  const configPrismaPorts = createConfigPrismaPorts(prisma);
+  const filePrismaPorts = createFilePrismaPorts(prisma);
+  const inquiryPrismaPorts = createInquiryPrismaPorts(prisma);
+  const postPrismaPorts = createPostPrismaPorts(prisma);
+  const seoMetadataPrismaPorts = createSeoMetadataPrismaPorts(prisma);
+  return createSiteroServer$1({
+    authentication: {
+      admin: {
+        refreshTokenTtlSeconds: input.authentication?.refreshTokenTtlSeconds
+      }
+    },
+    email: emailComposition.email,
+    ...policies ? { policies } : {},
+    uploads,
+    rateLimits: createRateLimits(input.rateLimits),
+    kernel: {
+      cache,
+      rateLimiter,
+      observer: input.kernel?.observer
+    },
+    ports: {
+      features: {
+        emailPreview: emailComposition.emailPreview,
+        uploads: {
+          storageUploadPort: storage
+        }
+      },
+      resources: {
+        admin: {
+          adminCommandPort: adminPrismaPorts.adminCommandPort,
+          adminInquiryNotificationRecipientQueryPort: adminPrismaPorts.adminInquiryNotificationRecipientQueryPort,
+          adminQueryPort: adminPrismaPorts.adminQueryPort
+        },
+        adminRefreshToken: {
+          adminRefreshTokenCommandPort: adminRefreshTokenPrismaPorts.adminRefreshTokenCommandPort,
+          adminRefreshTokenQueryPort: adminRefreshTokenPrismaPorts.adminRefreshTokenQueryPort
+        },
+        config: {
+          configCommandPort: configPrismaPorts.configCommandPort,
+          configQueryPort: configPrismaPorts.configQueryPort
+        },
+        file: {
+          fileCommandPort: filePrismaPorts.fileCommandPort,
+          fileQueryPort: filePrismaPorts.fileQueryPort,
+          fileReplaceContentPort: filePrismaPorts.fileReplaceContentPort,
+          storageRemovePort: storage
+        },
+        inquiry: {
+          inquiryCommandPort: inquiryPrismaPorts.inquiryCommandPort,
+          inquiryQueryPort: inquiryPrismaPorts.inquiryQueryPort
+        },
+        post: {
+          postCommandPort: postPrismaPorts.postCommandPort,
+          postQueryPort: postPrismaPorts.postQueryPort
+        },
+        seoMetadata: {
+          seoMetadataCommandPort: seoMetadataPrismaPorts.seoMetadataCommandPort
+        }
+      },
+      authentication: {
+        admin: {
+          adminAuthenticationCommandPort: createAdminAuthenticationPrismaPort(prisma),
+          authenticationPasswordPort: createAuthenticationPasswordPort(),
+          authenticationTokenPort: authenticationToken
+        }
+      }
+    }
+  });
+}
+
+export { createSiteroServer };

package/dist/src/core/sitero-server/email.js

@@ -0,0 +1,113 @@
+import { createAdminVerificationEmailSender, createAdminForgotPasswordEmailSender, createNewInquiryEmailSender } from 'sitero-server';
+import 'sitero-domain';
+import { EMAIL_DEFINITION_KEYS } from '../../config/emails.js';
+import { CMS_PATHS } from '../../constants/paths/cms-paths.js';
+import '../../constants/paths/redirect.js';
+import '../../constants/cms-locale.js';
+import { createTransporter, createNodemailerEmailDeliveryPort } from '../infrastructure/email/delivery.js';
+import { createFilesystemEmailComposer } from '../infrastructure/email/filesystem-email-composer.js';
+import { createUrlEmailLinkBuilderPort } from '../infrastructure/email/link.js';
+
+function createEmailComposition({
+  email,
+  logger,
+  authenticationToken
+}) {
+  const transporter = createTransporter(email.delivery.transporter);
+  const emailDeliveryPort = createNodemailerEmailDeliveryPort({
+    transporter,
+    logger
+  });
+  const emailComposer = createFilesystemEmailComposer({
+    catalog: email.catalog,
+    url: email.rendering.webUrl,
+    logoUrl: email.rendering.logoUrl,
+    siteName: email.rendering.siteName,
+    logger
+  });
+  const emailLinkBuilderPort = createUrlEmailLinkBuilderPort({
+    url: email.rendering.webUrl
+  });
+  const adminVerificationEmailSender = createAdminVerificationEmailSender({
+    verifyEmailPathname: CMS_PATHS.auth["verify-email"].pathname,
+    createEmailVerificationToken: ({ adminId }) => authenticationToken.signAdminEmailVerificationToken({ adminId }),
+    emailComposerPort: {
+      compose: ({ locale, emailVerificationUrl }) => emailComposer.compose({
+        key: EMAIL_DEFINITION_KEYS.adminVerification,
+        locale,
+        replacements: { emailVerificationUrl }
+      })
+    },
+    emailDeliveryPort,
+    emailLinkBuilderPort
+  });
+  const adminForgotPasswordEmailSender = createAdminForgotPasswordEmailSender({
+    resetPasswordPathname: CMS_PATHS.auth["reset-password"].pathname,
+    createPasswordResetToken: ({ adminId }) => authenticationToken.signAdminPasswordResetToken({ adminId }),
+    emailComposerPort: {
+      compose: ({ locale, passwordResetUrl }) => emailComposer.compose({
+        key: EMAIL_DEFINITION_KEYS.adminForgotPassword,
+        locale,
+        replacements: { passwordResetUrl }
+      })
+    },
+    emailDeliveryPort,
+    emailLinkBuilderPort
+  });
+  const newInquiryEmailSender = createNewInquiryEmailSender({
+    inquiryPathname: CMS_PATHS.website.inquiry.pathname,
+    emailComposerPort: {
+      compose: ({ locale, url }) => emailComposer.compose({
+        key: EMAIL_DEFINITION_KEYS.newInquiry,
+        locale,
+        replacements: { url }
+      })
+    },
+    emailDeliveryPort,
+    emailLinkBuilderPort
+  });
+  return {
+    email: {
+      authentication: {
+        admin: {
+          verification: {
+            sender: adminVerificationEmailSender
+          },
+          forgotPassword: {
+            sender: adminForgotPasswordEmailSender
+          }
+        }
+      },
+      inquiry: {
+        newInquiry: {
+          sender: newInquiryEmailSender
+        }
+      }
+    },
+    // [Feature] Preview emails
+    emailPreview: {
+      emailTemplateCatalogPort: {
+        list() {
+          return Object.entries(email.catalog).map(([key, definition]) => ({
+            key,
+            fallbackLocale: definition.fallbackLocale
+          }));
+        }
+      },
+      emailTemplateRendererPort: {
+        render: ({ key, locale }) => emailComposer.compose({
+          key,
+          locale,
+          // Preview data never generates tokens or invokes a sender.
+          replacements: {
+            emailVerificationUrl: "https://example.invalid/email-preview/verify",
+            passwordResetUrl: "https://example.invalid/email-preview/reset",
+            url: "https://example.invalid/email-preview/inquiry"
+          }
+        })
+      }
+    }
+  };
+}
+
+export { createEmailComposition };

package/dist/src/core/sitero-server/rate-limits.js

@@ -0,0 +1,145 @@
+function createRateLimits(overrides) {
+  const normalizeEmail = (email) => email.trim().toLowerCase();
+  return {
+    // -----------------------------------------------------------------------
+    // authentication
+    // -----------------------------------------------------------------------
+    authentication: {
+      admin: {
+        signIn: {
+          key: (input, context) => [
+            "cms",
+            "admin",
+            "sign-in",
+            context.request?.ip ?? input.ip ?? "unknown"
+          ],
+          limit: 10,
+          windowSeconds: 60
+        },
+        verify: {
+          key: (_input, context) => [
+            "cms",
+            "admin",
+            "verify",
+            context.request?.ip ?? "unknown"
+          ],
+          limit: 300,
+          windowSeconds: 60
+        },
+        emailUnverified: {
+          key: (input, context) => [
+            "cms",
+            "admin",
+            "email-unverified",
+            context.request?.ip ?? "unknown",
+            normalizeEmail(input.email)
+          ],
+          limit: 3,
+          windowSeconds: 60
+        },
+        forgotPassword: {
+          key: (input, context) => [
+            "cms",
+            "admin",
+            "forgot-password",
+            context.request?.ip ?? "unknown",
+            normalizeEmail(input.email)
+          ],
+          limit: 3,
+          windowSeconds: 60
+        },
+        verifyEmail: {
+          key: (_input, context) => [
+            "cms",
+            "admin",
+            "verify-email",
+            context.request?.ip ?? "unknown"
+          ],
+          limit: 10,
+          windowSeconds: 60
+        },
+        resetPassword: {
+          key: (_input, context) => [
+            "cms",
+            "admin",
+            "reset-password",
+            context.request?.ip ?? "unknown"
+          ],
+          limit: 10,
+          windowSeconds: 60
+        },
+        ...overrides?.authentication?.admin
+      }
+    },
+    // -----------------------------------------------------------------------
+    // features
+    // -----------------------------------------------------------------------
+    features: {
+      // --- inquiry
+      inquiry: {
+        submit: {
+          key: (_input, context) => [
+            "web",
+            "inquiry",
+            "submit",
+            context.request?.ip ?? "unknown"
+          ],
+          limit: 3,
+          windowSeconds: 60
+        },
+        ...overrides?.features?.inquiry
+      },
+      // --- email-preview
+      emailPreview: {
+        listTemplates: {
+          key: (_input, context) => [
+            "cms",
+            "api",
+            "emails",
+            context.request?.ip ?? "unknown"
+          ],
+          limit: 60,
+          windowSeconds: 60
+        },
+        renderTemplate: {
+          key: (input, context) => [
+            "cms",
+            "api",
+            "preview-email",
+            input.key,
+            context.request?.ip ?? "unknown"
+          ],
+          limit: 60,
+          windowSeconds: 60
+        },
+        ...overrides?.features?.emailPreview
+      },
+      // --- uploads
+      uploads: {
+        uploadFile: {
+          key: (_input, context) => [
+            "cms",
+            "api",
+            "file-upload",
+            context.request?.ip ?? "unknown"
+          ],
+          limit: 60,
+          windowSeconds: 60
+        },
+        uploadFiles: {
+          key: (_input, context) => [
+            "cms",
+            "api",
+            "multi-files-upload",
+            context.request?.ip ?? "unknown"
+          ],
+          limit: 60,
+          windowSeconds: 60
+        },
+        ...overrides?.features?.uploads
+      }
+    }
+  };
+}
+
+export { createRateLimits };

package/dist/src/shared/client/hooks/use-count-down.js

@@ -0,0 +1,35 @@
+"use client";
+import { useState, useRef, useCallback, useEffect } from 'react';
+
+const useCountdown = (initialTime) => {
+  const [timeLeft, setTimeLeft] = useState(initialTime);
+  const [isCounting, setIsCounting] = useState(false);
+  const intervalRef = useRef(null);
+  const startCountdown = useCallback(() => {
+    setTimeLeft(initialTime);
+    setIsCounting(true);
+  }, [initialTime]);
+  useEffect(() => {
+    if (!isCounting) return;
+    intervalRef.current = setInterval(() => {
+      setTimeLeft((prev) => {
+        if (prev <= 1) {
+          clearInterval(intervalRef.current);
+          intervalRef.current = null;
+          setIsCounting(false);
+          return 0;
+        }
+        return prev - 1;
+      });
+    }, 1e3);
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+    };
+  }, [isCounting]);
+  return { timeLeft, isCounting, startCountdown };
+};
+
+export { useCountdown };

package/dist/src/shared/client/hooks/use-device-info.js

@@ -0,0 +1,29 @@
+"use client";
+import { useState, useEffect, startTransition } from 'react';
+import { UAParser } from 'ua-parser-js';
+
+function useDeviceInfo() {
+  const [deviceInfo, setDeviceInfo] = useState(null);
+  useEffect(() => {
+    const parser = new UAParser(navigator.userAgent);
+    const result = parser.getResult();
+    startTransition(
+      () => setDeviceInfo({
+        deviceType: result.device.type || "desktop",
+        platform: result.os.name || "Unknown",
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        language: navigator.language,
+        screenResolution: {
+          width: window.screen.width,
+          height: window.screen.height
+        },
+        browser: result.browser.name || "Unknown",
+        browserVersion: result.browser.version || "",
+        userAgent: navigator.userAgent
+      })
+    );
+  }, []);
+  return deviceInfo;
+}
+
+export { useDeviceInfo };

package/dist/src/shared/client/react-query/use-command.js

@@ -0,0 +1,50 @@
+"use client";
+import { useMutation } from '@tanstack/react-query';
+import { useState } from 'react';
+import { queryClient } from './client.js';
+
+function useCommand(fn, mutationOptions) {
+  const [isRedirecting, setIsRedirecting] = useState(false);
+  const [errors, setErrors] = useState([]);
+  const {
+    shouldTrigger,
+    clearAll = true,
+    onFailure,
+    ...reactQueryOptions
+  } = mutationOptions || {};
+  const mutation = useMutation({
+    ...reactQueryOptions,
+    mutationFn: async (params) => {
+      const response = await fn(params);
+      if (response.success) {
+        setErrors([]);
+        if (clearAll) await queryClient.invalidateQueries();
+        return response.data;
+      }
+      setErrors(
+        (response.error.fields ?? []).map((field) => field.path.join(".")).filter((f) => typeof f === "string")
+      );
+      onFailure?.(response.error);
+      throw new Error(response.error.code);
+    }
+  });
+  const execute = (async (params) => {
+    try {
+      if (shouldTrigger) {
+        const shouldProceed = await shouldTrigger(params);
+        if (!shouldProceed) {
+          setIsRedirecting(false);
+          return void 0;
+        }
+      }
+      setIsRedirecting(true);
+      return await mutation.mutateAsync(params);
+    } catch {
+      setIsRedirecting(false);
+      return void 0;
+    }
+  });
+  return { ...mutation, execute, isRedirecting, errors };
+}
+
+export { useCommand };

package/dist/src/shared/client/react-query/use-query.js

@@ -0,0 +1,19 @@
+"use client";
+import { useQuery as useQuery$1 } from '@tanstack/react-query';
+
+function useQuery(fn, queryKey, queryOptions) {
+  const { params, ...rest } = queryOptions || {};
+  const query = useQuery$1({
+    queryKey: params ? [...queryKey, params] : queryKey,
+    queryFn: async () => {
+      const response = await fn(params);
+      if (response.success) return response.data;
+      throw new Error(response.error.code);
+    },
+    ...rest
+  });
+  const isNotFound = !query.isPending && !query.data;
+  return { ...query, isNotFound };
+}
+
+export { useQuery };

package/dist/src/shared/fetch/response-interceptor.js

@@ -0,0 +1,22 @@
+function createResponseInterceptor({ logger }) {
+  const responseInterceptor = async (response, ctx) => {
+    const duration = Date.now() - (ctx.meta.startTime ?? 0);
+    if (!response.ok) {
+      logger.warn("HTTP error", {
+        url: ctx.meta.url,
+        status: response.status,
+        duration
+      });
+      return await response.json();
+    }
+    const data = await response.json();
+    logger.debug("Fetch success", {
+      url: ctx.meta.url,
+      duration
+    });
+    return data;
+  };
+  return responseInterceptor;
+}
+
+export { createResponseInterceptor };

package/dist/src/shared/fetch/smart-fetch.js

@@ -0,0 +1,28 @@
+import { createRequestInterceptor } from './request-interceptor.js';
+import { createResponseInterceptor } from './response-interceptor.js';
+
+function createSmartFetch({
+  baseUrl,
+  logger
+}) {
+  const requestInterceptor = createRequestInterceptor({ baseUrl });
+  const responseInterceptor = createResponseInterceptor({ logger });
+  const smartFetch = async (input, init = {}) => {
+    try {
+      let ctx = {
+        input,
+        init,
+        meta: {}
+      };
+      ctx = await requestInterceptor(ctx);
+      const response = await fetch(ctx.input, ctx.init);
+      return await responseInterceptor(response, ctx);
+    } catch (error) {
+      logger.error("smartFetch error", { error });
+      throw error instanceof Error ? error : new Error("Network Error");
+    }
+  };
+  return smartFetch;
+}
+
+export { createSmartFetch };

package/dist/src/shared/next/server/request.js

@@ -0,0 +1,13 @@
+import { headers } from 'next/headers';
+
+function resolveRequestIpFromHeaders(headers2) {
+  return headers2?.get("cf-connecting-ip")?.trim() || headers2?.get("x-forwarded-for")?.split(",")[0]?.trim() || headers2?.get("x-real-ip")?.trim() || "unknown";
+}
+const resolveRequestContext = async () => {
+  const headerStore = await headers();
+  return {
+    request: { ip: resolveRequestIpFromHeaders(headerStore) }
+  };
+};
+
+export { resolveRequestContext, resolveRequestIpFromHeaders };

package/dist/src/shared/next/server/response.js

@@ -0,0 +1,56 @@
+import { NextResponse } from 'next/server';
+import { operationResult } from 'sitero-server';
+import { ZodError } from 'zod';
+
+function toFieldPath(path) {
+  return path.filter(
+    (item) => typeof item === "string" || typeof item === "number"
+  );
+}
+function getOperationFailureStatus(error) {
+  switch (error.code) {
+    case "RATE_LIMITED":
+      return 429;
+    case "UNAUTHENTICATED":
+      return 401;
+    case "UNAUTHORIZED":
+      return 403;
+    case "VALIDATION_FAILED":
+      return 422;
+    default:
+      return void 0;
+  }
+}
+function toNextJsonResponse(result, init) {
+  if (init || result.success) return NextResponse.json(result, init);
+  const status = getOperationFailureStatus(result.error);
+  return NextResponse.json(result, status ? { status } : void 0);
+}
+function toNextFailureJsonResponse(error, init) {
+  return toNextJsonResponse(operationResult.failure(error), init);
+}
+function toNextErrorResponse(error) {
+  if (error instanceof ZodError) {
+    return toNextFailureJsonResponse(
+      {
+        code: "VALIDATION_FAILED",
+        fields: error.issues.map((issue) => ({
+          path: toFieldPath(issue.path),
+          code: issue.code
+        }))
+      },
+      { status: 422 }
+    );
+  }
+  return toNextFailureJsonResponse(
+    {
+      code: "INTERNAL_ERROR",
+      details: {
+        message: error instanceof Error ? error.message : "Internal server error"
+      }
+    },
+    { status: 500 }
+  );
+}
+
+export { toNextErrorResponse, toNextFailureJsonResponse, toNextJsonResponse };

package/dist/src/shared/units.js

@@ -1,5 +1,3 @@
-const SIZE = {
-  MB: 1024 ** 2};
 const TIME = {
   SECOND: 1,
   MINUTE: 60,
@@ -7,4 +5,4 @@ const TIME = {
   DAY: 60 ** 2 * 24
 };
 
-export { SIZE, TIME };
+export { TIME };