@raketa-cloud/admin 0.0.102 → 0.0.103

package/src/routeNestedCollection.js

@@ -0,0 +1,96 @@
+const routeNestedCollection = (
+  adapter,
+  parent,
+  resource,
+  handler,
+  resourceConfig = {}
+) => {
+  const {
+    before_filter,
+    after_filter,
+    index,
+    show,
+    create_form,
+    edit_form,
+    create,
+    update,
+    destroy,
+  } = handler;
+
+  const mapping = [
+    [
+      "GET",
+      `/${parent}/:parent_id/${resource}`,
+      resource,
+      `${parent}/${resource}`,
+      "index",
+      index,
+      before_filter,
+      after_filter,
+    ],
+    [
+      "GET",
+      `/${parent}/:parent_id/${resource}/new`,
+      resource,
+      `${parent}/${resource}`,
+      "create_form",
+      create_form,
+      before_filter,
+      after_filter,
+    ],
+    [
+      "GET",
+      `/${resource}/:id`,
+      resource,
+      `${parent}/${resource}`,
+      "show",
+      show,
+      before_filter,
+      after_filter,
+    ],
+    [
+      "GET",
+      `/${resource}/:id/edit`,
+      resource,
+      `${parent}/${resource}`,
+      "edit_form",
+      edit_form,
+      before_filter,
+      after_filter,
+    ],
+    [
+      "POST",
+      `/${parent}/:parent_id/${resource}`,
+      resource,
+      `${parent}/${resource}`,
+      "create_form",
+      create,
+      before_filter,
+      after_filter,
+    ],
+    [
+      "PUT",
+      `/${resource}/:id`,
+      resource,
+      `${parent}/${resource}`,
+      "update",
+      update,
+      before_filter,
+      after_filter,
+    ],
+    [
+      "DELETE",
+      `/${resource}/:id`,
+      resource,
+      `${parent}/${resource}`,
+      "destroy",
+      destroy,
+      before_filter,
+      after_filter,
+    ],
+  ];
+
+  adapter.routeNestedCollection(mapping, resourceConfig);
+};
+
+export default routeNestedCollection;

package/src/routeNestedMember.js

@@ -0,0 +1,46 @@
+const routeNestedMember = (
+  adapter,
+  parent,
+  resource,
+  handler,
+  resourceConfig = {}
+) => {
+  const { before_filter, after_filter, show, edit_form, update } = handler;
+
+  const mapping = [
+    [
+      "GET",
+      `/${parent}/:parent_id/${resource}`,
+      resource,
+      `${parent}/${resource}`,
+      "show",
+      show,
+      before_filter,
+      after_filter,
+    ],
+    [
+      "GET",
+      `/${parent}/:parent_id/${resource}/edit`,
+      resource,
+      `${parent}/${resource}`,
+      "edit_form",
+      edit_form,
+      before_filter,
+      after_filter,
+    ],
+    [
+      "POST",
+      `/${parent}/:parent_id/${resource}`,
+      resource,
+      `${parent}/${resource}`,
+      "edit_form",
+      update,
+      before_filter,
+      after_filter,
+    ],
+  ];
+
+  adapter.routeNestedMember(mapping, resourceConfig);
+};
+
+export default routeNestedMember;

package/src/routePagesModule.js

@@ -0,0 +1,163 @@
+import CancelSchedulesHandler from "./handlers/page_revisions/CancelSchedulesHandler";
+import CodeHandler from "./handlers/page_revisions/CodeHandler";
+import GeneralHandler from "./handlers/page_revisions/GeneralHandler";
+import LocksHandler from "./handlers/page_revisions/LocksHandler";
+import MetaHandler from "./handlers/page_revisions/MetaHandler";
+import PageRevisionsHandler from "./handlers/page_revisions/PageRevisionsHandler";
+import PublishesHandler from "./handlers/page_revisions/PublishesHandler";
+import RevertsHandler from "./handlers/page_revisions/RevertsHandler";
+import TagHandler from "./handlers/page_revisions/TagHandler";
+import UnlocksHandler from "./handlers/page_revisions/UnlocksHandler";
+import VisualHandler from "./handlers/page_revisions/VisualHandler";
+import WidgetHandler from "./handlers/page_revisions/WidgetHandler";
+import ClonesHandler from "./handlers/pages/ClonesHandler";
+import DeletesHandler from "./handlers/pages/DeletesHandler";
+import HistoryHandler from "./handlers/pages/HistoryHandler";
+import PagesHandler from "./handlers/pages/PagesHandler";
+import TranslationsHandler from "./handlers/pages/TranslationsHandler";
+import URLsHandler from "./handlers/pages/URLsHandler";
+import routeCollection from "./routeCollection";
+import routeNestedCollection from "./routeNestedCollection";
+import routeNestedMember from "./routeNestedMember";
+
+function routePagesModule(
+  adapter,
+  pageType = "page",
+  pageTypePlural = "pages"
+) {
+  const baseResource = pageTypePlural;
+  const revisionsBaseResource = `${pageType}_revisions`;
+
+  const resourceConfig = {
+    pageType,
+    pageTypePlural,
+  };
+
+  routeCollection(adapter, pageTypePlural, PagesHandler, {
+    ...resourceConfig,
+    viewsFallback: "pages",
+  });
+
+  routeNestedCollection(
+    adapter,
+    baseResource,
+    "translations",
+    TranslationsHandler,
+    { ...resourceConfig, viewsFallback: "pages/translations" }
+  );
+
+  routeNestedCollection(adapter, baseResource, "history", HistoryHandler, {
+    ...resourceConfig,
+    viewsFallback: "pages/history",
+  });
+
+  routeNestedCollection(
+    adapter,
+    baseResource,
+    revisionsBaseResource,
+    PageRevisionsHandler,
+    {
+      ...resourceConfig,
+      viewsFallback: "pages/page_revisions",
+    }
+  );
+
+  routeNestedMember(adapter, revisionsBaseResource, "general", GeneralHandler, {
+    ...resourceConfig,
+    viewsFallback: "page_revisions/general",
+  });
+
+  routeNestedMember(adapter, revisionsBaseResource, "visuals", VisualHandler, {
+    ...resourceConfig,
+    viewsFallback: "page_revisions/visuals",
+  });
+
+  routeNestedMember(adapter, revisionsBaseResource, "codes", CodeHandler, {
+    ...resourceConfig,
+    viewsFallback: "page_revisions/codes",
+  });
+
+  routeNestedMember(adapter, revisionsBaseResource, "meta", MetaHandler, {
+    ...resourceConfig,
+    viewsFallback: "page_revisions/meta",
+  });
+
+  routeNestedMember(adapter, revisionsBaseResource, "tags", TagHandler, {
+    ...resourceConfig,
+    viewsFallback: "page_revisions/tags",
+  });
+
+  routeNestedCollection(adapter, revisionsBaseResource, "locks", LocksHandler, {
+    ...resourceConfig,
+    viewsFallback: "page_revisions/locks",
+  });
+
+  routeNestedCollection(
+    adapter,
+    revisionsBaseResource,
+    "unlocks",
+    UnlocksHandler,
+    {
+      ...resourceConfig,
+      viewsFallback: "page_revisions/unlocks",
+    }
+  );
+
+  routeNestedCollection(adapter, baseResource, "clones", ClonesHandler, {
+    ...resourceConfig,
+    viewsFallback: "pages/clones",
+  });
+
+  routeNestedCollection(adapter, baseResource, "urls", URLsHandler, {
+    ...resourceConfig,
+    viewsFallback: "pages/urls",
+  });
+
+  routeNestedCollection(adapter, baseResource, "deletes", DeletesHandler, {
+    ...resourceConfig,
+    viewsFallback: "pages/deletes",
+  });
+
+  routeNestedCollection(
+    adapter,
+    baseResource,
+    `${pageType}_changes/reverts`,
+    RevertsHandler,
+    {
+      ...resourceConfig,
+      viewsFallback: "page_changes/reverts",
+    }
+  );
+
+  routeNestedCollection(
+    adapter,
+    revisionsBaseResource,
+    "publishes",
+    PublishesHandler,
+    {
+      ...resourceConfig,
+      viewsFallback: "page_revisions/publishes",
+    }
+  );
+
+  routeNestedCollection(
+    adapter,
+    revisionsBaseResource,
+    "cancel_schedules",
+    CancelSchedulesHandler,
+    {
+      ...resourceConfig,
+      viewsFallback: "page_revisions/cancel_schedules",
+    }
+  );
+
+  routeNestedMember(
+    adapter,
+    `api/${revisionsBaseResource}`,
+    "widgets",
+    WidgetHandler,
+    resourceConfig
+  );
+}
+
+export default routePagesModule;

package/src/routeSettings.js

@@ -0,0 +1,14 @@
+import routeMember from "./routeMember";
+import SettingsHandler from "./handlers/_shared/SettingsHandler";
+
+function routeSettings(adapter) {
+  routeMember(adapter, "settings/meta", SettingsHandler, {
+    resource: "settings/meta",
+  });
+
+  routeMember(adapter, "settings/layout", SettingsHandler, {
+    resource: "settings/layout",
+  });
+}
+
+export default routeSettings;

package/src/routeStandard.js

@@ -0,0 +1,35 @@
+import routeCollection from "./routeCollection";
+import routeSettings from "./routeSettings";
+import routePagesModule from "./routePagesModule";
+import routeArticlesModule from "./routeArticlesModule";
+import routeEventsModule from "./routeEventsModule";
+import RedirectsHandler from "./handlers/RedirectsHandler";
+import TagsHandler from "./handlers/TagsHandler";
+import DashboardsHandler from "./handlers/DashboardsHandler";
+
+function routeStandard(adapter) {
+  adapter.routeCollection(
+    [
+      [
+        "GET",
+        "",
+        "dashboard",
+        "dashboard",
+        "index",
+        DashboardsHandler.index,
+        undefined,
+        undefined,
+      ],
+    ],
+    {}
+  );
+
+  routeCollection(adapter, "redirects", RedirectsHandler);
+  routeCollection(adapter, "tags", TagsHandler);
+  routeSettings(adapter);
+  routePagesModule(adapter);
+  routeArticlesModule(adapter);
+  routeEventsModule(adapter);
+}
+
+export default routeStandard;

package/src/setGlobalContext.js

@@ -0,0 +1,5 @@
+const setGlobalContext = (adapter, func) => {
+  adapter.setGlobalContext(func);
+};
+
+export default setGlobalContext;

package/src/setupAuthentication.js

@@ -0,0 +1,154 @@
+import ejs from "ejs";
+import { deleteCookie, getCookie, setCookie } from "hono/cookie";
+import currentPath from "./currentPath.cjs";
+import AuthHelper from "./helpers/AuthHelper";
+import cipher from "./cipher";
+
+const DELIMITER = ",";
+
+function obfuscateToken(token, config) {
+  const date = new Date();
+  const timestamp = date.getTime() + 2 * 60000;
+  const data = [token, timestamp].join(DELIMITER);
+
+  return Buffer.from(cipher.encrypt(data, config)).toString("base64");
+}
+
+function extractToken(text, config) {
+  const encrypted = Buffer.from(text, "base64").toString("ascii");
+  const data = cipher.decrypt(encrypted, config);
+  const [token, timestamp] = data.split(DELIMITER);
+
+  const tDate = new Date(Number.parseInt(timestamp, 10));
+
+  if (tDate < new Date()) {
+    return null;
+  }
+
+  return token;
+}
+
+function getAuthBearer(c) {
+  const authHeader = c.req.header("Authorization") || "";
+
+  return authHeader.replace("Bearer", "").trim();
+}
+
+function unauthorized() {
+  return new Response("Unauthorized", {
+    status: 401,
+    headers: {
+      Authenticate: 'error="invalid_token"',
+    },
+  });
+}
+
+const setupAuthentication = (app, config) => {
+  app.use(async (c, next) => {
+    const token = getCookie(c, AuthHelper.cookie_key) || getAuthBearer(c);
+
+    const status = AuthHelper.isAuthenticated({ path: c.req.path, token });
+
+    if (!status) {
+      return c.redirect("/login");
+    }
+
+    if (token) {
+      const { info } = AuthHelper.parseJWT(token);
+      c.set("authentication", { token, user: info });
+    }
+
+    await next();
+  });
+
+  app.get("/login", async (c) => {
+    const googleURL = AuthHelper.getGoogleURL({
+      gateway_url: config.cloud.gateway_url,
+      gateway_project: config.cloud.gateway_project,
+      gateway_user_pool: config.cloud.gateway_user_pool,
+      auth_callback_url: config.cloud.auth_callback_url,
+    });
+
+    const templatePath = `${currentPath}/views/_auth/login.ejs`;
+
+    const rendered = await ejs.renderFile(templatePath, {
+      googleURL,
+      error: c.req.query("err"),
+    });
+
+    return c.html(rendered);
+  });
+
+  app.get("/auth/google/callback", (c) => {
+    const token = c.req.query("token") || "";
+
+    const {
+      info: { active },
+    } = AuthHelper.parseJWT(token);
+
+    if (!AuthHelper.verifyJWT(token)) return c.redirect("/login?err=expired");
+    if (!active) return c.redirect("/login?err=not_activated");
+
+    const isLocalhost = c.req.url.includes("http://localhost");
+
+    setCookie(c, AuthHelper.cookie_key, token, {
+      path: "/",
+      httpOnly: true,
+      secure: !isLocalhost,
+    });
+
+    return c.redirect("/remote/login");
+  });
+
+  app.get("/logout", (c) => {
+    deleteCookie(c, AuthHelper.cookie_key);
+
+    return c.redirect(config.remoteConfig.remoteLogout);
+  });
+
+  // Routes related to the remote project handling
+  app.get("/profile", (c) => {
+    const token = getAuthBearer(c);
+
+    // TODO: Here we may update the Gateway API to have the check dynamically done in the backend!
+    if (AuthHelper.verifyJWT(token)) {
+      return c.json({ message: "OK" });
+    } else {
+      return unauthorized();
+    }
+  });
+
+  app.get("/remote/login", (c) => {
+    const token = getCookie(c, AuthHelper.cookie_key);
+
+    if (!AuthHelper.verifyJWT(token)) {
+      return c.redirect("/login");
+    }
+
+    const ot = obfuscateToken(token, config);
+
+    return c.redirect(
+      [
+        config.remoteConfig.remoteLogin,
+        "?redirect_to=",
+        c.req.query().redirect_to,
+        "&snapshot=",
+        ot,
+      ].join("")
+    );
+  });
+
+  app.post("/remote/verify", async (c) => {
+    const { credentials } = await c.req.json();
+
+    const token = extractToken(credentials, config);
+
+    if (!token) {
+      return unauthorized();
+    }
+
+    return c.json({ token });
+  });
+};
+
+export default setupAuthentication;

package/src/setupCloud.js

@@ -0,0 +1,50 @@
+import Redirects from "./cloud/Redirects";
+import Settings from "./cloud/Settings";
+import Tags from "./cloud/Tags";
+import Pages from "./cloud/Pages";
+import PageRevisions from "./cloud/PageRevisions";
+import PageChanges from "./cloud/PageChanges";
+import Articles from "./cloud/Articles";
+import ArticleRevisions from "./cloud/ArticleRevisions";
+import ArticleChanges from "./cloud/ArticleChanges";
+import Events from "./cloud/Events";
+import EventRevisions from "./cloud/EventRevisions";
+import EventChanges from "./cloud/EventChanges";
+import Categories from "./cloud/Categories";
+
+function setupCloud(ctx, getConfig) {
+  if (!ctx?.authentication?.token) return;
+
+  ctx.client = {};
+
+  ctx.client.redirects = new Redirects(getConfig, ctx.authentication.token);
+  ctx.client.settings = new Settings(getConfig, ctx.authentication.token);
+  ctx.client.tags = new Tags(getConfig, ctx.authentication.token);
+  ctx.client.pages = new Pages(getConfig, ctx.authentication.token);
+  ctx.client.pageRevisions = new PageRevisions(
+    getConfig,
+    ctx.authentication.token
+  );
+  ctx.client.pageChanges = new PageChanges(getConfig, ctx.authentication.token);
+  ctx.client.articles = new Articles(getConfig, ctx.authentication.token);
+  ctx.client.articleRevisions = new ArticleRevisions(
+    getConfig,
+    ctx.authentication.token
+  );
+  ctx.client.articleChanges = new ArticleChanges(
+    getConfig,
+    ctx.authentication.token
+  );
+  ctx.client.events = new Events(getConfig, ctx.authentication.token);
+  ctx.client.eventRevisions = new EventRevisions(
+    getConfig,
+    ctx.authentication.token
+  );
+  ctx.client.eventChanges = new EventChanges(
+    getConfig,
+    ctx.authentication.token
+  );
+  ctx.client.categories = new Categories(getConfig, ctx.authentication.token);
+}
+
+export default setupCloud;