sitero 0.1.6 → 0.2.0

package/dist/src/cms/server/resources/file/actions.js

@@ -0,0 +1,186 @@
+import { operationResult } from 'sitero-server';
+
+function toFileCreateInput(file) {
+  return {
+    key: file.key,
+    originalName: file.fileMeta.name,
+    size: file.fileMeta.size,
+    mimeType: file.fileMeta.type,
+    width: file.width ?? null,
+    height: file.height ?? null,
+    duration: file.duration ?? null,
+    translations: file.translations
+  };
+}
+function toFileReplaceContentInput(input) {
+  const { formData, id } = input;
+  if (!formData.key) return null;
+  return {
+    id,
+    key: formData.key,
+    originalName: formData.fileMeta.name,
+    size: formData.fileMeta.size,
+    mimeType: formData.fileMeta.type,
+    width: formData.width ?? null,
+    height: formData.height ?? null,
+    duration: formData.duration ?? null
+  };
+}
+function toFileUpdateInput(input) {
+  return {
+    id: input.id,
+    translations: input.formData.translations
+  };
+}
+function hasBatchMutationFailure(input) {
+  return input.failed.length > 0 && input.completed.length === 0;
+}
+function getFirstSkippedCode(input) {
+  return input[0]?.code ?? "INTERNAL_ERROR";
+}
+function createFileActions({
+  resolveExecutionContext,
+  siteroServer
+}) {
+  const fileCreateAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    return await siteroServer.executor.execute(
+      siteroServer.resources.file.create,
+      toFileCreateInput(input.formData),
+      contextResult.data
+    );
+  };
+  const fileCreateManyAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    const result = await siteroServer.executor.execute(
+      siteroServer.resources.file.createMany,
+      { files: input.formData.uploadResults.map(toFileCreateInput) },
+      contextResult.data
+    );
+    if (!result.success) return result;
+    if (hasBatchMutationFailure({
+      failed: result.data.failed,
+      completed: result.data.created
+    })) {
+      return operationResult.failure({ code: "INTERNAL_ERROR" });
+    }
+    return operationResult.success({
+      count: result.data.created.length
+    });
+  };
+  const fileUpdateAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    const replaceContentInput = toFileReplaceContentInput(input);
+    if (replaceContentInput) {
+      const replaceResult = await siteroServer.executor.execute(
+        siteroServer.resources.file.replaceContent,
+        replaceContentInput,
+        contextResult.data
+      );
+      if (!replaceResult.success) return replaceResult;
+    }
+    return await siteroServer.executor.execute(
+      siteroServer.resources.file.update,
+      toFileUpdateInput(input),
+      contextResult.data
+    );
+  };
+  const fileSoftDeleteAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    return await siteroServer.executor.execute(
+      siteroServer.resources.file.delete,
+      input,
+      contextResult.data
+    );
+  };
+  const fileSoftDeleteManyAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    const result = await siteroServer.executor.execute(
+      siteroServer.resources.file.deleteMany,
+      input.formData,
+      contextResult.data
+    );
+    if (!result.success) return result;
+    if (hasBatchMutationFailure({
+      failed: result.data.failed,
+      completed: result.data.deleted
+    }) || result.data.deleted.length === 0) {
+      return operationResult.failure({
+        code: result.data.skipped.length > 0 ? getFirstSkippedCode(result.data.skipped) : "INTERNAL_ERROR"
+      });
+    }
+    return operationResult.success(void 0);
+  };
+  const fileRestoreManyAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    const result = await siteroServer.executor.execute(
+      siteroServer.resources.file.restoreMany,
+      input.formData,
+      contextResult.data
+    );
+    if (!result.success) return result;
+    if (hasBatchMutationFailure({
+      failed: result.data.failed,
+      completed: result.data.restored
+    }) || result.data.restored.length === 0) {
+      return operationResult.failure({ code: "INTERNAL_ERROR" });
+    }
+    return operationResult.success(void 0);
+  };
+  const filePurgeManyAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    const result = await siteroServer.executor.execute(
+      siteroServer.resources.file.purgeMany,
+      input.formData,
+      contextResult.data
+    );
+    if (!result.success) return result;
+    if (hasBatchMutationFailure({
+      failed: result.data.failed,
+      completed: result.data.purged
+    }) || result.data.purged.length === 0) {
+      return operationResult.failure({
+        code: result.data.skipped.length > 0 ? getFirstSkippedCode(result.data.skipped) : "INTERNAL_ERROR"
+      });
+    }
+    return operationResult.success(void 0);
+  };
+  const fileFindDetailAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    return siteroServer.executor.execute(
+      siteroServer.resources.file.findDetail,
+      input,
+      contextResult.data
+    );
+  };
+  const fileFindListCardsAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    return siteroServer.executor.execute(
+      siteroServer.resources.file.findListCards,
+      input,
+      contextResult.data
+    );
+  };
+  return {
+    create: fileCreateAction,
+    createMany: fileCreateManyAction,
+    findDetail: fileFindDetailAction,
+    findListCards: fileFindListCardsAction,
+    purgeMany: filePurgeManyAction,
+    restoreMany: fileRestoreManyAction,
+    softDelete: fileSoftDeleteAction,
+    softDeleteMany: fileSoftDeleteManyAction,
+    update: fileUpdateAction
+  };
+}
+
+export { createFileActions };

package/dist/src/cms/server/resources/inquiry/actions.js

@@ -0,0 +1,39 @@
+function createInquiryActions({
+  resolveExecutionContext,
+  siteroServer
+}) {
+  const inquiryDeleteAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    return await siteroServer.executor.execute(
+      siteroServer.resources.inquiry.delete,
+      input,
+      contextResult.data
+    );
+  };
+  const inquiryFindAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    return siteroServer.executor.execute(
+      siteroServer.resources.inquiry.find,
+      input,
+      contextResult.data
+    );
+  };
+  const inquiryFindListCardsAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    return siteroServer.executor.execute(
+      siteroServer.resources.inquiry.findListCards,
+      input,
+      contextResult.data
+    );
+  };
+  return {
+    delete: inquiryDeleteAction,
+    find: inquiryFindAction,
+    findListCards: inquiryFindListCardsAction
+  };
+}
+
+export { createInquiryActions };

package/dist/src/cms/server/resources/post/actions.js

@@ -0,0 +1,202 @@
+import { operationResult } from 'sitero-server';
+
+function toItem(id) {
+  return id ? { id } : null;
+}
+function toItems(items) {
+  return items?.map(({ id }) => ({ id })) ?? [];
+}
+function toItemsFromIds(ids) {
+  return ids?.map((id) => ({ id })) ?? [];
+}
+function toPostTranslationWriteInput(translation) {
+  return {
+    content: translation.content,
+    data1: translation.data1,
+    data2: translation.data2,
+    data3: translation.data3,
+    data4: translation.data4,
+    description: translation.description,
+    externalLinks: translation.externalLinks,
+    faq: translation.faq,
+    locale: translation.locale,
+    readTime: translation.readTime !== 0 ? translation.readTime : null,
+    subtitle: translation.subtitle,
+    summary: translation.summary,
+    text1: translation.text1,
+    text2: translation.text2,
+    text3: translation.text3,
+    text4: translation.text4,
+    text5: translation.text5,
+    text6: translation.text6,
+    text7: translation.text7,
+    text8: translation.text8,
+    text9: translation.text9,
+    text10: translation.text10,
+    title: translation.title,
+    toc: translation.toc,
+    wordCount: translation.wordCount
+  };
+}
+function toPostCreateInput({
+  formData
+}) {
+  const {
+    author,
+    contentImageIds,
+    coverImage,
+    file1,
+    file2,
+    file3,
+    file4,
+    files1,
+    files2,
+    parents,
+    relatedPosts,
+    tags,
+    topicId
+  } = formData;
+  return {
+    author: author ? { id: author.id } : null,
+    contentImages: toItemsFromIds(contentImageIds),
+    coverImage: coverImage ? { id: coverImage.id } : null,
+    data1: formData.data1,
+    data2: formData.data2,
+    data3: formData.data3,
+    data4: formData.data4,
+    dec1: formData.dec1,
+    dec2: formData.dec2,
+    dec3: formData.dec3,
+    dec4: formData.dec4,
+    file1: file1 ? { id: file1.id } : null,
+    file2: file2 ? { id: file2.id } : null,
+    file3: file3 ? { id: file3.id } : null,
+    file4: file4 ? { id: file4.id } : null,
+    files1: toItems(files1),
+    files2: toItems(files2),
+    index: formData.index,
+    int1: formData.int1,
+    int2: formData.int2,
+    int3: formData.int3,
+    int4: formData.int4,
+    isActive: formData.isActive,
+    isFeatured: formData.isFeatured,
+    isIndexActive: formData.isIndexActive,
+    isShownOnHome: formData.isShownOnHome,
+    isSlugActive: formData.isSlugActive,
+    parents: toItems(parents),
+    relatedPosts: toItems(relatedPosts),
+    slug: formData.slug,
+    state1: formData.state1,
+    state2: formData.state2,
+    state3: formData.state3,
+    state4: formData.state4,
+    state5: formData.state5,
+    state6: formData.state6,
+    state7: formData.state7,
+    state8: formData.state8,
+    state9: formData.state9,
+    state10: formData.state10,
+    tags: toItems(tags),
+    text1: formData.text1,
+    text2: formData.text2,
+    text3: formData.text3,
+    text4: formData.text4,
+    text5: formData.text5,
+    text6: formData.text6,
+    text7: formData.text7,
+    text8: formData.text8,
+    text9: formData.text9,
+    text10: formData.text10,
+    topic: toItem(topicId),
+    translations: formData.translations.map(toPostTranslationWriteInput),
+    type: formData.type
+  };
+}
+function toPostUpdateInput({
+  formData,
+  id
+}) {
+  const { type: _type, ...createInput } = toPostCreateInput({
+    formData
+  });
+  return {
+    id,
+    ...createInput
+  };
+}
+function createPostActions({
+  resolveExecutionContext,
+  siteroServer
+}) {
+  const postCreateAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    return await siteroServer.executor.execute(
+      siteroServer.resources.post.create,
+      toPostCreateInput(input),
+      contextResult.data
+    );
+  };
+  const postUpdateAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    return await siteroServer.executor.execute(
+      siteroServer.resources.post.update,
+      toPostUpdateInput(input),
+      contextResult.data
+    );
+  };
+  const postDeleteAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    return await siteroServer.executor.execute(
+      siteroServer.resources.post.delete,
+      input,
+      contextResult.data
+    );
+  };
+  const postFindDetailAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    const result = await siteroServer.executor.execute(
+      siteroServer.resources.post.findDetail,
+      input,
+      contextResult.data
+    );
+    if (!result.success) return result;
+    return operationResult.success({
+      next: result.data.next ?? void 0,
+      post: result.data.post,
+      prev: result.data.previous ?? void 0
+    });
+  };
+  const postFindListCardsAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    return siteroServer.executor.execute(
+      siteroServer.resources.post.findListCards,
+      input,
+      contextResult.data
+    );
+  };
+  const postFindManyAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    return siteroServer.executor.execute(
+      siteroServer.resources.post.findMany,
+      input,
+      contextResult.data
+    );
+  };
+  return {
+    create: postCreateAction,
+    delete: postDeleteAction,
+    findDetail: postFindDetailAction,
+    findListCards: postFindListCardsAction,
+    findMany: postFindManyAction,
+    update: postUpdateAction
+  };
+}
+
+export { createPostActions };

package/dist/src/cms/server/resources/seo-metadata/actions.js

@@ -0,0 +1,54 @@
+function normalizeDatetime(date) {
+  if (date == null) return null;
+  const normalizedDate = typeof date === "string" ? new Date(date) : date;
+  if (Number.isNaN(normalizedDate.getTime())) return null;
+  return normalizedDate.toISOString();
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeJsonLd(data) {
+  if (data == null) return [];
+  if (Array.isArray(data)) return data.filter(isObject);
+  if (typeof data === "string") {
+    if (data.trim() === "") return [];
+    const parsed = JSON.parse(data);
+    if (Array.isArray(parsed)) return parsed.filter(isObject);
+    if (isObject(parsed)) return [parsed];
+    return [];
+  }
+  if (isObject(data)) return [data];
+  return [];
+}
+function createSeoMetadataActions({
+  resolveExecutionContext,
+  siteroServer
+}) {
+  const seoMetadataUpsertAction = async (input) => {
+    const contextResult = await resolveExecutionContext();
+    if (!contextResult.success) return contextResult;
+    const formData = {
+      ...input.formData,
+      translations: input.formData.translations.map((translation) => ({
+        ...translation,
+        ogArticlePublishedTime: normalizeDatetime(
+          translation.ogArticlePublishedTime
+        ),
+        ogArticleModifiedTime: normalizeDatetime(
+          translation.ogArticleModifiedTime
+        ),
+        jsonLd: normalizeJsonLd(translation.jsonLd)
+      }))
+    };
+    return await siteroServer.executor.execute(
+      siteroServer.resources.seoMetadata.upsert,
+      formData,
+      contextResult.data
+    );
+  };
+  return {
+    upsert: seoMetadataUpsertAction
+  };
+}
+
+export { createSeoMetadataActions };

package/dist/src/cms/server/sessions/admin/admin-session-runtime.js

@@ -0,0 +1,78 @@
+import { operationResult } from 'sitero-server';
+
+function createAdminSessionRuntime({
+  authenticate,
+  resolveRequestContext,
+  cookies,
+  appName,
+  accessTokenTtlSeconds = 15 * 60,
+  refreshTokenTtlSeconds = 7 * 24 * 60 * 60
+}) {
+  const accessCookieName = `${appName}_sitero_server_admin_access_token`;
+  const refreshCookieName = `${appName}_sitero_server_admin_refresh_token`;
+  const cookieOptions = {
+    httpOnly: true,
+    secure: process.env.NODE_ENV === "production",
+    sameSite: "strict",
+    path: "/"
+  };
+  async function getRefreshToken() {
+    const cookieStore = await cookies();
+    return cookieStore.get(refreshCookieName)?.value;
+  }
+  async function setTokens(tokens) {
+    const cookieStore = await cookies();
+    cookieStore.set(accessCookieName, tokens.accessToken, {
+      ...cookieOptions,
+      maxAge: accessTokenTtlSeconds
+    });
+    cookieStore.set(refreshCookieName, tokens.refreshToken, {
+      ...cookieOptions,
+      maxAge: refreshTokenTtlSeconds
+    });
+  }
+  async function clearTokens() {
+    const cookieStore = await cookies();
+    cookieStore.delete(accessCookieName);
+    cookieStore.delete(refreshCookieName);
+  }
+  async function authenticateSession(deviceInfo) {
+    const cookieStore = await cookies();
+    const requestContext = await resolveRequestContext();
+    const input = {
+      accessToken: cookieStore.get(accessCookieName)?.value,
+      refreshToken: cookieStore.get(refreshCookieName)?.value,
+      ip: requestContext.request?.ip ?? "unknown",
+      deviceInfo: deviceInfo ?? null
+    };
+    const result = await authenticate(input);
+    if (result.status === "authenticated" && result.tokens) {
+      await setTokens(result.tokens);
+    }
+    if (result.status === "unauthenticated" && result.shouldClearSession) {
+      await clearTokens();
+    }
+    return result;
+  }
+  async function resolveExecutionContext(deviceInfo) {
+    const result = await authenticateSession(deviceInfo);
+    if (result.status === "unauthenticated") {
+      return operationResult.failure({
+        code: "UNAUTHENTICATED"
+      });
+    }
+    return operationResult.success({
+      actor: result.actor,
+      ...await resolveRequestContext(),
+      session: result.session
+    });
+  }
+  return {
+    getRefreshToken,
+    setTokens,
+    clearTokens,
+    resolveExecutionContext
+  };
+}
+
+export { createAdminSessionRuntime };

package/dist/src/config/emails.js

@@ -0,0 +1,7 @@
+const EMAIL_DEFINITION_KEYS = {
+  adminVerification: "authentication.admin.verify-email",
+  adminForgotPassword: "authentication.admin.forgot-password",
+  newInquiry: "inquiry.new-inquiry"
+};
+
+export { EMAIL_DEFINITION_KEYS };

package/dist/src/constants/paths/cms-paths.js

@@ -26,8 +26,6 @@ const CMS_PATHS = {
     },
     storage: {
       pathname: `${DB}/system/storage`,
-      "file-manager": { pathname: `${DB}/system/storage/file-manager` },
-      folder: { pathname: `${DB}/system/storage/folder` },
       file: { pathname: `${DB}/system/storage/file` },
       trash: { pathname: `${DB}/system/storage/trash` }
     }

package/dist/src/core/infrastructure/authentication/authentication-password-port.js

@@ -0,0 +1,20 @@
+import argon2 from 'argon2';
+
+const ARGON2ID_OPTIONS = {
+  type: argon2.argon2id,
+  memoryCost: 19456,
+  timeCost: 2,
+  parallelism: 1
+};
+function createAuthenticationPasswordPort() {
+  return {
+    hashPassword(password) {
+      return argon2.hash(password, ARGON2ID_OPTIONS);
+    },
+    verifyPassword({ passwordHash, password }) {
+      return argon2.verify(passwordHash, password);
+    }
+  };
+}
+
+export { createAuthenticationPasswordPort };

package/dist/src/core/infrastructure/authentication/authentication-token-port.js

@@ -0,0 +1,95 @@
+import { createHmac, randomBytes } from 'node:crypto';
+import { createAuthenticationTokenCodec } from './helpers/authentication-token-codec.js';
+import { deriveAuthenticationTokenKey } from './helpers/authentication-token-key.js';
+import { resolveSecurityConfig, resolveTtlSeconds } from './helpers/resolvers.js';
+
+const DEFAULT_ACCESS_TOKEN_TTL_SECONDS = 15 * 60;
+const DEFAULT_EMAIL_VERIFICATION_TOKEN_TTL_SECONDS = 60 * 60;
+const DEFAULT_PASSWORD_RESET_TOKEN_TTL_SECONDS = 10 * 60;
+function createAuthenticationTokenPort(config) {
+  const { appName, secret } = resolveSecurityConfig(config);
+  const accessTokenTtlSeconds = resolveTtlSeconds(
+    config.accessTokenTtlSeconds,
+    DEFAULT_ACCESS_TOKEN_TTL_SECONDS,
+    "accessTokenTtlSeconds"
+  );
+  const emailVerificationTokenTtlSeconds = resolveTtlSeconds(
+    config.adminEmailVerificationTokenTtlSeconds,
+    DEFAULT_EMAIL_VERIFICATION_TOKEN_TTL_SECONDS,
+    "adminEmailVerificationTokenTtlSeconds"
+  );
+  const passwordResetTokenTtlSeconds = resolveTtlSeconds(
+    config.adminPasswordResetTokenTtlSeconds,
+    DEFAULT_PASSWORD_RESET_TOKEN_TTL_SECONDS,
+    "adminPasswordResetTokenTtlSeconds"
+  );
+  const { sign, verify } = createAuthenticationTokenCodec({ appName, secret });
+  return {
+    // --------------------------------------------------------------------
+    // Access token
+    // --------------------------------------------------------------------
+    signAccessToken(input) {
+      return sign("access", input, accessTokenTtlSeconds);
+    },
+    verifyAccessToken(accessToken) {
+      const payload = verify("access", accessToken);
+      if (typeof payload["actorId"] !== "string" || payload["actorType"] !== "admin" && payload["actorType"] !== "user") {
+        throw new TypeError("Invalid access token payload");
+      }
+      return {
+        actorId: payload["actorId"],
+        actorType: payload["actorType"],
+        ...typeof payload["sessionId"] === "string" ? { sessionId: payload["sessionId"] } : {},
+        ...typeof payload["role"] === "string" ? { role: payload["role"] } : {}
+      };
+    },
+    // --------------------------------------------------------------------
+    // Refresh token
+    // --------------------------------------------------------------------
+    generateRefreshToken() {
+      return randomBytes(32).toString("base64url");
+    },
+    hashRefreshToken(refreshToken) {
+      const refreshTokenHashKey = deriveAuthenticationTokenKey(
+        { appName, secret },
+        "refresh-token-hash"
+      );
+      return createHmac("sha256", refreshTokenHashKey).update(refreshToken).digest("hex");
+    },
+    // --------------------------------------------------------------------
+    // Admin
+    // --------------------------------------------------------------------
+    // --- admin-email-verification
+    signAdminEmailVerificationToken({ adminId }) {
+      return sign(
+        "admin-email-verification",
+        { adminId },
+        emailVerificationTokenTtlSeconds
+      );
+    },
+    verifyAdminEmailVerificationToken({ token }) {
+      const payload = verify("admin-email-verification", token);
+      if (typeof payload["adminId"] !== "string") {
+        throw new TypeError("Invalid admin email-verification token payload");
+      }
+      return { adminId: payload["adminId"] };
+    },
+    // --- admin-password-reset
+    signAdminPasswordResetToken({ adminId }) {
+      return sign(
+        "admin-password-reset",
+        { adminId },
+        passwordResetTokenTtlSeconds
+      );
+    },
+    verifyAdminPasswordResetToken({ token }) {
+      const payload = verify("admin-password-reset", token);
+      if (typeof payload["adminId"] !== "string") {
+        throw new TypeError("Invalid admin password-reset token payload");
+      }
+      return { adminId: payload["adminId"] };
+    }
+  };
+}
+
+export { createAuthenticationTokenPort };