@raketa-cloud/admin 0.0.102 → 1.0.0

package/src/handlers/pages/TranslationsHandler.js

@@ -0,0 +1,233 @@
+const index = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const { translations } = ctx.query;
+  let translatedPages = [];
+
+  if (translations) {
+    const translationPairs = translations.split(";").map((pair) => {
+      const [locale, id] = pair.split(":");
+      return { locale, id };
+    });
+
+    translatedPages = await Promise.all(
+      translationPairs.map(async ({ locale, id }) => {
+        const page = await ctx.client.pages.find(id, locale);
+
+        if (!page) {
+          throw new Error(
+            `Cannot find translated page with id ${id} and locale ${locale}`
+          );
+        }
+
+        const revisions = await ctx.client.pageRevisions.all(id, locale);
+        const openRevision = revisions.list[0];
+
+        return {
+          ...page,
+          translationLocale: locale,
+          revisionId: openRevision?.id,
+        };
+      })
+    );
+  }
+
+  const items = await ctx.client.pages.list(
+    ctx.query,
+    ctx.locale,
+    ctx.resourceConfig.pageType
+  );
+
+  const originalPage = await ctx.client.pages.find(parent_id, ctx.locale);
+
+  return {
+    assigns: {
+      items,
+      visibilityOptions: ctx.client.pages.visibilityOptions(),
+      translations: translatedPages,
+      parent_id,
+      pageTitle: originalPage.title,
+    },
+  };
+};
+
+const create_form = async (ctx) => {
+  const { target_locale = "" } = ctx.query;
+
+  const { parent_id } = ctx.params;
+  const blueprint = await ctx.client.pages.find(parent_id, ctx.locale);
+
+  if (!blueprint) {
+    throw new Error(`Cannot find page with id ${parent_id}`);
+  }
+
+  const resource = structuredClone(blueprint);
+
+  return {
+    assigns: {
+      resource,
+      blueprint,
+      targetLocale: target_locale,
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const originalLocale = ctx.locale;
+  const blueprint = await ctx.client.pages.find(parent_id, originalLocale);
+
+  if (!ctx.resourceParams?.resource?.languages) {
+    return {
+      assigns: {
+        resource: {
+          translations: blueprint.translations || {},
+          languages: [],
+        },
+        blueprint,
+        targetLocale: originalLocale,
+        errors: {
+          resource: ctx.client.pages.formatErrors([
+            {
+              key: "languages",
+              message: "select at least one language for translation",
+            },
+          ]),
+        },
+      },
+    };
+  }
+
+  const formLanguages = Array.isArray(ctx.resourceParams.resource.languages)
+    ? ctx.resourceParams.resource.languages
+    : [ctx.resourceParams.resource.languages].filter(Boolean);
+
+  const existingTranslations = Object.keys(blueprint.translations || {});
+  const selectedLocales = formLanguages.filter(
+    (locale) =>
+      locale !== originalLocale && !existingTranslations.includes(locale)
+  );
+
+  const params = {
+    title: blueprint.title,
+    tags: [],
+    visibility: "private",
+    slug: blueprint.slug,
+  };
+
+  const resource = ctx.client.pages.deepMerge(
+    {
+      settings: blueprint.settings,
+      widgets: blueprint.widgets,
+      categories: blueprint.categories.map((category) => category.id),
+    },
+    params
+  );
+
+  const translationIds = [];
+
+  const translations = await ctx.client.pages.translateBatch(
+    parent_id,
+    selectedLocales,
+    resource
+  );
+
+  if (!translations) {
+    return {
+      assigns: {
+        resource: {
+          ...resource,
+          translations: blueprint.translations || {},
+          languages: formLanguages,
+        },
+        blueprint,
+        targetLocale: originalLocale,
+        errors: {
+          resource: ctx.client.pages.formatErrors([
+            {
+              key: "generalError",
+              message: "Failed to process translations",
+            },
+          ]),
+        },
+      },
+    };
+  }
+
+  for (let i = 0; i < translations.length; i++) {
+    const { page } = translations[i];
+    const locale = selectedLocales[i];
+
+    if (page) {
+      blueprint.translations = {
+        ...blueprint.translations,
+        [locale]: {
+          id: page.id,
+          slug: page.slug,
+          visibility: page.visibility,
+        },
+      };
+    }
+  }
+
+  const revisionInputs = [];
+
+  for (let i = 0; i < translations.length; i++) {
+    const { errors, page } = translations[i];
+    const locale = selectedLocales[i];
+
+    if (errors) {
+      return {
+        assigns: {
+          resource: {
+            ...resource,
+            translations: blueprint.translations || {},
+            languages: formLanguages,
+          },
+          blueprint,
+          targetLocale: locale,
+          errors: { resource: ctx.client.pages.formatErrors(errors) },
+        },
+      };
+    }
+
+    if (page) {
+      translationIds.push(`${locale}:${page.id}`);
+      revisionInputs.push({ pageId: page.id, locale });
+    }
+  }
+
+  const revisionResults =
+    await ctx.client.pageRevisions.createBatch(revisionInputs);
+
+  for (let i = 0; i < revisionResults.length; i++) {
+    const { errors: revisionErrors } = revisionResults[i];
+    if (revisionErrors) {
+      return {
+        assigns: {
+          resource: {
+            ...resource,
+            translations: blueprint.translations || {},
+            languages: formLanguages,
+          },
+          blueprint,
+          targetLocale: selectedLocales[i],
+          errors: {
+            resource: ctx.client.pages.formatErrors(revisionErrors),
+          },
+        },
+      };
+    }
+  }
+
+  return {
+    redirect: `/${originalLocale}/${ctx.resourceConfig.pageTypePlural}/${parent_id}/translations?translations=${translationIds.join(";")}`,
+  };
+};
+
+export default {
+  index,
+  create_form,
+  create,
+};

package/src/handlers/pages/URLsHandler.js

@@ -0,0 +1,77 @@
+const create_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const page = await ctx.client.pages.find(parent_id, ctx.locale);
+
+  if (!page) {
+    throw new Error(
+      `Cannot find ${ctx.resourceConfig.pageType} with id ${parent_id}`
+    );
+  }
+
+  return {
+    assigns: {
+      page,
+      resource: {
+        id: page.id,
+        slug: page.slug,
+        redirect: null,
+      },
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const resource = ctx.resourceParams.resource;
+
+  const page = await ctx.client.pages.find(parent_id, ctx.locale);
+
+  if (!page) {
+    throw new Error(
+      `Cannot find ${ctx.resourceConfig.pageType} with id ${parent_id}`
+    );
+  }
+
+  let redirectParams = null;
+
+  if (resource.redirect) {
+    redirectParams = {
+      url: ctx.remoteConfig.resourcePath(page, page.pageType.slug, ctx.locale),
+      destination: ctx.remoteConfig.resourcePath(
+        { slug: resource.slug },
+        page.pageType.slug,
+        ctx.locale
+      ),
+      httpResponseCode: 301,
+      note: `Created with changed URL for a ${ctx.resourceConfig.pageType}`,
+    };
+  }
+
+  const { errors } = await ctx.client.pages.updateSlug(
+    parent_id,
+    resource.slug,
+    ctx.locale,
+    redirectParams
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        resource: { ...resource, id: page.id },
+        errors: { resource: ctx.client.pages.formatErrors(errors, "redirect") },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/${ctx.resourceConfig.pageTypePlural}/${parent_id}`,
+  };
+};
+
+export default {
+  create_form,
+  create,
+};

package/src/helpers/AuthHelper.js

@@ -0,0 +1,49 @@
+const AuthHelper = {
+  cookie_key: "auth_cookie",
+
+  parseJWT: (token) => {
+    return JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
+  },
+
+  verifyJWT: (token) => {
+    const { exp } = AuthHelper.parseJWT(token);
+    if (!exp) return false;
+
+    const now = new Date();
+
+    if (exp > now.getTime() / 1000) return true;
+
+    return false;
+  },
+
+  isAuthenticated: ({ path, token }) => {
+    const ALLOWED_PATHS = ["/login", "/auth/google/callback", "/remote/verify"];
+
+    if (ALLOWED_PATHS.includes(path)) return true;
+
+    if (token && AuthHelper.verifyJWT(token)) return true;
+
+    return false;
+  },
+
+  getGoogleURL: ({
+    gateway_url,
+    gateway_project,
+    gateway_user_pool,
+    auth_callback_url,
+  }) => {
+    if (
+      ![
+        gateway_url,
+        gateway_project,
+        gateway_user_pool,
+        auth_callback_url,
+      ].every(Boolean)
+    )
+      throw new Error("Invalid ENVs for authentication configuration");
+
+    return `${gateway_url}/users/auth/${gateway_project}/${gateway_user_pool}/google?return_to=${auth_callback_url}`;
+  },
+};
+
+export default AuthHelper;