@raketa-cloud/admin 1.6.1 → 1.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raketa-cloud/admin",
-  "version": "1.6.1",
+  "version": "1.6.3",
   "main": "src/index.js",
   "files": [
     "src/",
@@ -12,19 +12,19 @@
     "prepare": "npx tailwindcss -i ./src/styles/application.css -o ./dist/application.css"
   },
   "devDependencies": {
-    "@babel/core": "7.26.10",
-    "@babel/preset-env": "7.26.9",
-    "@babel/preset-typescript": "7.26.0",
+    "@babel/core": "7.27.1",
+    "@babel/preset-env": "7.27.2",
+    "@babel/preset-typescript": "7.27.1",
     "@repo/typescript-config": "*",
     "@tailwindcss/forms": "0.5.7",
     "@tailwindcss/typography": "0.5.13",
-    "@types/node": "22.13.10",
+    "@types/node": "22.15.21",
     "jest": "29.7.0",
     "tailwindcss": "3.4.4",
-    "typescript": "5.8.2"
+    "typescript": "5.8.3"
   },
   "dependencies": {
     "ejs": "3.1.10",
-    "graphql-request": "7.1.2"
+    "graphql-request": "7.2.0"
   }
 }

package/src/HonoAdapter.js

@@ -16,14 +16,14 @@ import utils from "./helpers/utils";
 
 function escapeHtml(string) {
   const escape = {
-    '"': '"',
-    '&': '&',
-    "'": ''',
-    '<': '&lt;',
-    '>': '&gt;'
+    '"': "&quot;",
+    "&": "&amp;",
+    "'": "&#39;",
+    "<": "&lt;",
+    ">": "&gt;",
   };
 
-  return String(string).replace(/["&'<>]/g, char => escape[char]);
+  return String(string).replace(/["&'<>]/g, (char) => escape[char]);
 }
 
 const renderError = (message, stack) => {
@@ -38,7 +38,8 @@ const renderError = (message, stack) => {
 };
 
 // Convert to array if needed
-const toArray = value => Array.isArray(value) ? value : [value].filter(Boolean);
+const toArray = (value) =>
+  Array.isArray(value) ? value : [value].filter(Boolean);
 
 // Handle nested form values
 function putIn(result, key, value) {
@@ -50,9 +51,8 @@ function putIn(result, key, value) {
 
     if (isLastSegment) {
       // Set value at final segment
-      current[segment] = key.endsWith("[]") || Array.isArray(value)
-        ? toArray(value)
-        : value;
+      current[segment] =
+        key.endsWith("[]") || Array.isArray(value) ? toArray(value) : value;
     } else {
       // Create path to next segment
       current[segment] ??= {};
@@ -62,22 +62,26 @@ function putIn(result, key, value) {
 }
 
 // Normalize paths for consistent handling
-const sanitizePath = filePath => path.normalize(path.join("/", ...filePath.split("/")));
+const sanitizePath = (filePath) =>
+  path.normalize(path.join("/", ...filePath.split("/")));
 
 // Find template path with fallbacks
 function getPartialPath(partialPath, views, viewsFallback) {
   const paths = [
     sanitizePath(`${process.cwd()}/src/views/${views}/${partialPath}`),
     sanitizePath(`${currentPath}/views/${views}/${partialPath}`),
-    viewsFallback && sanitizePath(`${currentPath}/views/${viewsFallback}/${partialPath}`)
+    viewsFallback &&
+      sanitizePath(`${currentPath}/views/${viewsFallback}/${partialPath}`),
   ].filter(Boolean);
 
   // Return first existing path
-  const existingPath = paths.find(path => existsSync(path));
+  const existingPath = paths.find((path) => existsSync(path));
 
   if (existingPath) return existingPath;
 
-  throw new Error(`Template not found: "${partialPath}"\nSearched in:\n${paths.join('\n')}`);
+  throw new Error(
+    `Template not found: "${partialPath}"\nSearched in:\n${paths.join("\n")}`
+  );
 }
 
 // Parse request body based on content type
@@ -109,6 +113,7 @@ export default class HonoAdapter {
     this.globalConfig = config;
     this.globalBeforeFilters = [];
     this.globalAfterFilters = [];
+    this.localRouter = [];
 
     // TODO: Pass in a path to redirect to after login?
     if (config) {
@@ -261,21 +266,48 @@ export default class HonoAdapter {
     });
   }
 
-  async createAction([verb, path, resource, views, action, handler], resourceConfig) {
-    const method = this.getMethod(verb);
+  addRoute(verb, path, handler) {
+    this.localRouter = this.localRouter.filter((routeItem) => {
+      return !(routeItem.verb === verb && routeItem.path === path);
+    });
+
+    this.localRouter.push({
+      verb,
+      path,
+      handler,
+    });
+  }
+
+  link() {
+    // Clean up all of hono's routes before linking to the adapter locally build routes
+    // this.router.routes = [];
+    // this.router.routes.length = 0;
+
+    this.localRouter.forEach((routeItem) => {
+      const method = this.getMethod(routeItem.verb);
+
+      method(routeItem.path, routeItem.handler);
+    });
+  }
+
+  async createAction(
+    [verb, path, resource, views, action, handler],
+    resourceConfig
+  ) {
     const { i18n } = this.globalConfig;
 
     Object.keys(i18n.locales).forEach((currentLocale) => {
       const completePath = `/${currentLocale}${path}`;
 
-      // Clean up existing routes with same path/verb
-      this.router.routes = this.router.routes.filter(route =>
-        route[0] !== verb || route[1] !== completePath
-      );
-
-      method(completePath, async (routerCtx, next) => {
+      this.addRoute(verb, completePath, async (routerCtx, next) => {
         // Create context with request data
-        const ctx = await this.createContext(routerCtx, next, verb, resource, action);
+        const ctx = await this.createContext(
+          routerCtx,
+          next,
+          verb,
+          resource,
+          action
+        );
 
         // Set context properties
         Object.assign(ctx, {
@@ -285,7 +317,7 @@ export default class HonoAdapter {
           maxOpenRevisions: this.globalConfig?.maxOpenRevisions || 3,
           locale: currentLocale,
           remoteConfig: { ...this.globalConfig.remoteConfig },
-          logger: Logger
+          logger: Logger,
         });
 
         // Build context object
@@ -301,15 +333,17 @@ export default class HonoAdapter {
           resourceConfig,
           adminJwt: ctx.authentication?.token,
           remoteConfig: { ...this.globalConfig.remoteConfig },
-          globalConfig: this.globalConfig
+          globalConfig: this.globalConfig,
         };
 
-        ctx.logger.info(`${ctx.method} "${ctx.rawPath}" -> ${resource}/${action} | ${JSON.stringify(ctx.params)}`);
+        ctx.logger.info(
+          `${ctx.method} "${ctx.rawPath}" -> ${resource}/${action} | ${JSON.stringify(ctx.params)}`
+        );
 
         const assigns = {
           beforeFilterAssigns: {},
           actionAssigns: {},
-          afterFilterAssigns: {}
+          afterFilterAssigns: {},
         };
 
         // Initialize global context
@@ -328,7 +362,7 @@ export default class HonoAdapter {
         }
 
         // Process action handler
-        const result = await handler(ctx, resourceConfig) || {};
+        const result = (await handler(ctx, resourceConfig)) || {};
         assigns.actionAssigns = result.assigns || {};
 
         if (result.headers) this.applyHeaders(result.headers, routerCtx);
@@ -340,10 +374,14 @@ export default class HonoAdapter {
           if (pattern.test(ctx.path)) {
             const afterResult = filter(ctx) || {};
 
-            if (afterResult.redirect) return routerCtx.redirect(afterResult.redirect);
+            if (afterResult.redirect)
+              return routerCtx.redirect(afterResult.redirect);
             if (afterResult.json) return routerCtx.json(afterResult.json);
 
-            Object.assign(assigns.afterFilterAssigns, afterResult.assigns || {});
+            Object.assign(
+              assigns.afterFilterAssigns,
+              afterResult.assigns || {}
+            );
           }
         }
 
@@ -353,16 +391,19 @@ export default class HonoAdapter {
           ...assigns.beforeFilterAssigns,
           ...assigns.actionAssigns,
           ...assigns.afterFilterAssigns,
-          _context
+          _context,
         };
 
         // Render the view
-        const rendered = this.renderAction({
-          views,
-          viewsFallback: resourceConfig.viewsFallback,
-          action,
-          assigns: fullAssigns
-        }, this.globalConfig?.helpers || {});
+        const rendered = this.renderAction(
+          {
+            views,
+            viewsFallback: resourceConfig.viewsFallback,
+            action,
+            assigns: fullAssigns,
+          },
+          this.globalConfig?.helpers || {}
+        );
 
         return routerCtx.html(rendered);
       });
@@ -371,7 +412,9 @@ export default class HonoAdapter {
 
   // Single method to handle all route types
   routeCollection(mapping, resourceConfig) {
-    mapping.forEach(handlerMap => this.createAction(handlerMap, resourceConfig));
+    mapping.forEach((handlerMap) =>
+      this.createAction(handlerMap, resourceConfig)
+    );
   }
 
   // Use the same implementation for all route types
@@ -391,7 +434,9 @@ export default class HonoAdapter {
 
   applyHeaders(headers, router) {
     if (!headers) return;
-    Object.entries(headers).forEach(([key, value]) => router.header(key, value));
+    Object.entries(headers).forEach(([key, value]) =>
+      router.header(key, value)
+    );
   }
 
   formatQuery(queries) {

package/src/cloud/Articles.js

@@ -1,15 +1,16 @@
-import { toDateInput, dateToUTCISO8601String } from "../utils";
+import { dateToUTCISO8601String, toDateInput } from "../utils";
 import RaketaClient from "./RaketaClient";
 import {
   ArticleByIdDocument,
+  ArticleChangePreviewDocument,
   ArticlesDocument,
   ChangeArticleSlugDocument,
   CloneArticleDocument,
   CreateArticleDocument,
-  buildBatchTranslateArticleDocument,
   DeleteArticleDocument,
   MiniArticlesDocument,
   TranslateArticleDocument,
+  buildBatchTranslateArticleDocument,
 } from "./documents/articlesDocuments";
 
 export default class Articles extends RaketaClient {
@@ -191,4 +192,21 @@ export default class Articles extends RaketaClient {
 
     return { article, errors };
   }
+
+  async getChangePreview(articleId, version, locale) {
+    const input = {
+      articleId,
+      version: Number.parseInt(version, 10),
+      locale,
+    };
+
+    const { articleChangePreview } = await this.query(
+      ArticleChangePreviewDocument,
+      {
+        input,
+      }
+    );
+
+    return articleChangePreview;
+  }
 }

package/src/cloud/Events.js

@@ -1,20 +1,21 @@
 import {
+  dateToUTCISO8601String,
+  toDateInput,
   toDateTimeInput,
   toUTCISO8601String,
-  toDateInput,
-  dateToUTCISO8601String,
 } from "../utils";
 import RaketaClient from "./RaketaClient";
 import {
   ChangeEventSlugDocument,
   CloneEventDocument,
-  buildBatchTranslateEventDocument,
   CreateEventDocument,
   DeleteEventDocument,
   EventByIdDocument,
+  EventChangePreviewDocument,
   EventsDocument,
   MiniEventsDocument,
   TranslateEventDocument,
+  buildBatchTranslateEventDocument,
 } from "./documents/eventsDocuments";
 
 export default class Events extends RaketaClient {
@@ -206,4 +207,21 @@ export default class Events extends RaketaClient {
 
     return { event, errors };
   }
+
+  async getChangePreview(eventId, version, locale) {
+    const input = {
+      eventId,
+      version: Number.parseInt(version, 10),
+      locale,
+    };
+
+    const { eventChangePreview } = await this.query(
+      EventChangePreviewDocument,
+      {
+        input,
+      }
+    );
+
+    return eventChangePreview;
+  }
 }

package/src/cloud/Pages.js

@@ -6,6 +6,7 @@ import {
   DeletePageDocument,
   MiniPagesDocument,
   PageByIdDocument,
+  PageChangePreviewDocument,
   PagesDocument,
   TranslatePageDocument,
   buildBatchTranslatePageDocument,
@@ -182,4 +183,18 @@ export default class Pages extends RaketaClient {
 
     return { page, errors };
   }
+
+  async getChangePreview(pageId, version, locale) {
+    const input = {
+      pageId,
+      version: Number.parseInt(version, 10),
+      locale,
+    };
+
+    const { pageChangePreview } = await this.query(PageChangePreviewDocument, {
+      input,
+    });
+
+    return pageChangePreview;
+  }
 }

package/src/cloud/documents/articlesDocuments.js

@@ -315,6 +315,34 @@ const UnlockArticleRevisionDocument = gql`
   }
 `;
 
+const ArticleChangePreviewDocument = gql`
+  query ($input: ArticleChangePreviewInput!) {
+    articleChangePreview(input: $input) {
+      article {
+        id
+        slug
+        title
+        widgets
+        settings
+        visibility
+        publishAt
+        translations
+        tags ${tagFragment()}
+        websiteSettings
+      }
+      articleChange {
+        version
+        title
+        description
+        operator
+        operatorMeta
+        source
+        insertedAt
+      }
+    }
+  }
+`;
+
 export {
   ArticleByIdDocument,
   ArticlesDocument,
@@ -340,4 +368,5 @@ export {
   buildBatchTranslateArticleDocument,
   buildBatchStartArticleRevisionDocument,
   ArticleEditorsDocument,
+  ArticleChangePreviewDocument,
 };

package/src/cloud/documents/eventsDocuments.js

@@ -323,6 +323,41 @@ const UnlockEventRevisionDocument = gql`
   }
 `;
 
+const EventChangePreviewDocument = gql`
+  query ($input: EventChangePreviewInput!) {
+    eventChangePreview(input: $input) {
+      event {
+        id
+        slug
+        title
+        widgets
+        settings
+        visibility
+        publishAt
+        startsAt
+        endsAt
+        eventType {
+          id
+          slug
+          title
+        }
+        translations
+        tags ${tagFragment()}
+        websiteSettings
+      }
+      eventChange {
+        version
+        title
+        description
+        operator
+        operatorMeta
+        source
+        insertedAt
+      }
+    }
+  }
+`;
+
 export {
   EventByIdDocument,
   EventsDocument,
@@ -348,4 +383,5 @@ export {
   buildBatchTranslateEventDocument,
   EventHistoryDocument,
   EventEditorsDocument,
+  EventChangePreviewDocument,
 };

package/src/cloud/documents/pagesDocuments.js

@@ -311,6 +311,33 @@ const UnlockPageRevisionDocument = gql`
   }
 `;
 
+const PageChangePreviewDocument = gql`
+  query ($input: PageChangePreviewInput!) {
+    pageChangePreview(input: $input) {
+      page {
+        id
+        slug
+        title
+        widgets
+        settings
+        visibility
+        translations
+        tags ${tagFragment()}
+        websiteSettings
+      }
+      pageChange {
+        version
+        title
+        description
+        operator
+        operatorMeta
+        source
+        insertedAt
+      }
+    }
+  }
+`;
+
 export {
   PageByIdDocument,
   PagesDocument,
@@ -336,4 +363,5 @@ export {
   PageHistoryDocument,
   buildBatchStartPageRevisionDocument,
   PageEditorsDocument,
+  PageChangePreviewDocument,
 };

package/src/handlers/TagsAPIHandler.js

@@ -0,0 +1,11 @@
+const index = async (ctx) => {
+  const items = await ctx.client.tags.list(ctx.query, ctx.locale);
+
+  return {
+    json: {
+      ...items,
+    },
+  };
+};
+
+export default { index };

package/src/handlers/articles/ArticlesAPIHandler.js

@@ -0,0 +1,15 @@
+const index = async (ctx) => {
+  const items = await ctx.client.articles.listAll(
+    ctx.query,
+    ctx.locale,
+    ctx.resourceConfig.articleType
+  );
+
+  return {
+    json: {
+      ...items,
+    },
+  };
+};
+
+export default { index };

package/src/handlers/articles/ChangeHandler.js

@@ -0,0 +1,22 @@
+const show = async (ctx) => {
+  const articleId = ctx.params.parent_id;
+  const version = ctx.query.version;
+
+  const item = await ctx.client.articles.getChangePreview(
+    articleId,
+    version,
+    ctx.locale
+  );
+
+  if (!item) {
+    throw new Error(`Missing ${ctx.resourceConfig.articleType} #${articleId}`);
+  }
+
+  return {
+    json: {
+      ...item,
+    },
+  };
+};
+
+export default { show };

package/src/handlers/events/ChangeHandler.js

@@ -0,0 +1,22 @@
+const show = async (ctx) => {
+  const eventId = ctx.params.parent_id;
+  const version = ctx.query.version;
+
+  const item = await ctx.client.events.getChangePreview(
+    eventId,
+    version,
+    ctx.locale
+  );
+
+  if (!item) {
+    throw new Error(`Missing ${ctx.resourceConfig.eventType} #${eventId}`);
+  }
+
+  return {
+    json: {
+      ...item,
+    },
+  };
+};
+
+export default { show };

package/src/handlers/events/EventsAPIHandler.js

@@ -0,0 +1,15 @@
+const index = async (ctx) => {
+  const items = await ctx.client.events.listAll(
+    ctx.query,
+    ctx.locale,
+    ctx.resourceConfig.eventType
+  );
+
+  return {
+    json: {
+      ...items,
+    },
+  };
+};
+
+export default { index };

package/src/handlers/pages/ChangeHandler.js

@@ -0,0 +1,22 @@
+const show = async (ctx) => {
+  const pageId = ctx.params.parent_id;
+  const version = ctx.query.version;
+
+  const item = await ctx.client.pages.getChangePreview(
+    pageId,
+    version,
+    ctx.locale
+  );
+
+  if (!item) {
+    throw new Error(`Missing ${ctx.resourceConfig.pageType} #${pageId}`);
+  }
+
+  return {
+    json: {
+      ...item,
+    },
+  };
+};
+
+export default { show };

package/src/handlers/pages/PagesAPIHandler.js

@@ -0,0 +1,15 @@
+const index = async (ctx) => {
+  const items = await ctx.client.pages.listAll(
+    ctx.query,
+    ctx.locale,
+    ctx.resourceConfig.pageType
+  );
+
+  return {
+    json: {
+      ...items,
+    },
+  };
+};
+
+export default { index };

package/src/helpers/AuthHelper.js

@@ -2,7 +2,13 @@ const AuthHelper = {
   cookie_key: "auth_cookie",
 
   parseJWT: (token) => {
-    return JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
+    const tokenPayload = token?.split(".")?.[1];
+
+    if(!tokenPayload){
+      return "";
+    }
+
+    return JSON.parse(Buffer.from(tokenPayload, "base64").toString());
   },
 
   verifyJWT: (token) => {

package/src/index.js

@@ -46,6 +46,7 @@ export { default as RedirectsHandler } from "./handlers/RedirectsHandler";
 export { default as TagsHandler } from "./handlers/TagsHandler";
 
 export { default as PageClonesHandler } from "./handlers/pages/ClonesHandler";
+export { default as ChangeHandler } from "./handlers/pages/ChangeHandler";
 export { default as PageDeletesHandler } from "./handlers/pages/DeletesHandler";
 export { default as PageTranslationsHandler } from "./handlers/pages/TranslationsHandler";
 export { default as PageURLsHandler } from "./handlers/pages/URLsHandler";

package/src/routeArticlesModule.js

@@ -10,7 +10,9 @@ import TagHandler from "./handlers/article_revisions/TagHandler";
 import UnlocksHandler from "./handlers/article_revisions/UnlocksHandler";
 import VisualHandler from "./handlers/article_revisions/VisualHandler";
 import WidgetHandler from "./handlers/article_revisions/WidgetHandler";
+import ArticlesAPIHandler from "./handlers/articles/ArticlesAPIHandler";
 import ArticlesHandler from "./handlers/articles/ArticlesHandler";
+import ChangeHandler from "./handlers/articles/ChangeHandler";
 import ClonesHandler from "./handlers/articles/ClonesHandler";
 import DeletesHandler from "./handlers/articles/DeletesHandler";
 import HistoryHandler from "./handlers/articles/HistoryHandler";
@@ -146,6 +148,15 @@ function routeArticlesModule(
     WidgetHandler,
     resourceConfig
   );
+
+  routeCollection(adapter, "api/articles", ArticlesAPIHandler, resourceConfig);
+  routeNestedMember(
+    adapter,
+    "api/article",
+    "change",
+    ChangeHandler,
+    resourceConfig
+  );
 }
 
 export default routeArticlesModule;

package/src/routeEventsModule.js

@@ -10,8 +10,10 @@ import TagHandler from "./handlers/event_revisions/TagHandler";
 import UnlocksHandler from "./handlers/event_revisions/UnlocksHandler";
 import VisualHandler from "./handlers/event_revisions/VisualHandler";
 import WidgetHandler from "./handlers/event_revisions/WidgetHandler";
+import ChangeHandler from "./handlers/events/ChangeHandler";
 import ClonesHandler from "./handlers/events/ClonesHandler";
 import DeletesHandler from "./handlers/events/DeletesHandler";
+import EventsAPIHandler from "./handlers/events/EventsAPIHandler";
 import EventsHandler from "./handlers/events/EventsHandler";
 import HistoryHandler from "./handlers/events/HistoryHandler";
 import TranslationsHandler from "./handlers/events/TranslationsHandler";
@@ -161,6 +163,15 @@ function routeEventsModule(
     WidgetHandler,
     resourceConfig
   );
+
+  routeCollection(adapter, "api/events", EventsAPIHandler, resourceConfig);
+  routeNestedMember(
+    adapter,
+    "api/event",
+    "change",
+    ChangeHandler,
+    resourceConfig
+  );
 }
 
 export default routeEventsModule;

package/src/routePagesModule.js

@@ -10,9 +10,11 @@ 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 ChangeHandler from "./handlers/pages/ChangeHandler";
 import ClonesHandler from "./handlers/pages/ClonesHandler";
 import DeletesHandler from "./handlers/pages/DeletesHandler";
 import HistoryHandler from "./handlers/pages/HistoryHandler";
+import PagesAPIHandler from "./handlers/pages/PagesAPIHandler";
 import PagesHandler from "./handlers/pages/PagesHandler";
 import TranslationsHandler from "./handlers/pages/TranslationsHandler";
 import URLsHandler from "./handlers/pages/URLsHandler";
@@ -158,6 +160,15 @@ function routePagesModule(
     WidgetHandler,
     resourceConfig
   );
+
+  routeCollection(adapter, "api/pages", PagesAPIHandler, resourceConfig);
+  routeNestedMember(
+    adapter,
+    "api/page",
+    "change",
+    ChangeHandler,
+    resourceConfig
+  );
 }
 
 export default routePagesModule;

package/src/routeStandard.js

@@ -1,11 +1,12 @@
-import routeCollection from "./routeCollection";
-import routeSettings from "./routeSettings";
-import routePagesModule from "./routePagesModule";
-import routeArticlesModule from "./routeArticlesModule";
-import routeEventsModule from "./routeEventsModule";
+import DashboardsHandler from "./handlers/DashboardsHandler";
 import RedirectsHandler from "./handlers/RedirectsHandler";
+import TagsAPIHandler from "./handlers/TagsAPIHandler";
 import TagsHandler from "./handlers/TagsHandler";
-import DashboardsHandler from "./handlers/DashboardsHandler";
+import routeArticlesModule from "./routeArticlesModule";
+import routeCollection from "./routeCollection";
+import routeEventsModule from "./routeEventsModule";
+import routePagesModule from "./routePagesModule";
+import routeSettings from "./routeSettings";
 
 function routeStandard(adapter) {
   adapter.routeCollection(
@@ -26,6 +27,7 @@ function routeStandard(adapter) {
 
   routeCollection(adapter, "redirects", RedirectsHandler);
   routeCollection(adapter, "tags", TagsHandler);
+  routeCollection(adapter, "api/tags", TagsAPIHandler);
   routeSettings(adapter);
   routePagesModule(adapter);
   routeArticlesModule(adapter);

package/src/tests/HonoAdapter.test.js

@@ -1,9 +1,10 @@
 import HonoAdapter from "../HonoAdapter";
+import RaketaContext from "../RaketaContext";
 
 class HonoMock {
   constructor() {
     this.router = {
-      routes: []
+      routes: [],
     };
     this.get = jest.fn();
     this.post = jest.fn();
@@ -11,18 +12,19 @@ class HonoMock {
     this.delete = jest.fn();
     this.use = jest.fn();
     this.header = jest.fn();
+    // this.routes = [];
   }
 }
 
 describe("HonoAdapter", () => {
   let app;
   let adapter;
-  
+
   beforeEach(() => {
     app = new HonoMock();
     adapter = new HonoAdapter(app);
   });
-  
+
   // Method tests
   test("getMethod returns Hono's get for invalid verbs", () => {
     expect(adapter.getMethod("not existing")).toBe(app.get);
@@ -78,58 +80,126 @@ describe("HonoAdapter", () => {
       },
     });
   });
-  
+
   test("setGlobalContext sets the global context function", () => {
     const newCtx = () => ({ test: true });
     adapter.setGlobalContext(newCtx);
     expect(adapter.globalCtx).toBe(newCtx);
   });
-  
+
   test("applyHeaders applies headers to router context", () => {
     const headers = {
       "Content-Type": "application/json",
-      "X-Custom-Header": "test-value"
+      "X-Custom-Header": "test-value",
     };
-    
+
     adapter.applyHeaders(headers, app);
-    
+
     expect(app.header).toHaveBeenCalledTimes(2);
     expect(app.header).toHaveBeenCalledWith("Content-Type", "application/json");
     expect(app.header).toHaveBeenCalledWith("X-Custom-Header", "test-value");
   });
-  
+
   test("applyHeaders does nothing when headers is undefined", () => {
     adapter.applyHeaders(undefined, app);
     expect(app.header).not.toHaveBeenCalled();
   });
-  
+
   test("formatQuery formats query parameters correctly", () => {
     const queries = {
       single: ["value"],
-      multiple: ["one", "two"]
+      multiple: ["one", "two"],
     };
-    
+
     const result = adapter.formatQuery(queries);
-    
+
     expect(result).toEqual({
       single: "value",
-      multiple: ["one", "two"]
+      multiple: ["one", "two"],
     });
   });
 
   test("parseFormBody handles array values", () => {
     expect(
       adapter.parseFormBody({
-        "tags[]": ["javascript", "react", "node"]
+        "tags[]": ["javascript", "react", "node"],
       })
     ).toEqual({
-      tags: ["javascript", "react", "node"]
+      tags: ["javascript", "react", "node"],
     });
   });
 
   test("parseFormBody handles empty values", () => {
-    expect(
-      adapter.parseFormBody({})
-    ).toEqual({});
+    expect(adapter.parseFormBody({})).toEqual({});
+  });
+
+  test("renderLayout renders an existing layout template", async () => {
+    const result = await adapter.renderLayout(
+      {
+        _context: {
+          layout: {
+            sidebar: [],
+          },
+          path: "/en/pages",
+          locale: "en",
+          locales: {
+            en: {
+              flag: "",
+              name: "English",
+            },
+          },
+          globalConfig: {
+            cloud: {
+              images_api_key: "api-key",
+            },
+          },
+        },
+      },
+      "<h1>Hi</h1>"
+    );
+
+    expect(typeof result).toBe("string");
+    expect(result.length).toBeGreaterThan(0);
+  });
+
+  test("addRouote - adds a route to the local router", () => {
+    expect(adapter.localRouter).toEqual([]);
+
+    const handler = () => {};
+
+    adapter.addRoute("GET", "/en/pages", handler);
+
+    expect(adapter.localRouter).toEqual([
+      { verb: "GET", path: "/en/pages", handler },
+    ]);
+  });
+
+  test("addRouote - overrides routes if they already exist in the local router", () => {
+    expect(adapter.localRouter).toEqual([]);
+
+    const handler = () => {};
+    const handler2 = () => {};
+
+    adapter.addRoute("GET", "/en/pages", handler);
+
+    expect(adapter.localRouter).toEqual([
+      { verb: "GET", path: "/en/pages", handler },
+    ]);
+
+    adapter.addRoute("GET", "/en/pages", handler2);
+
+    expect(adapter.localRouter).toEqual([
+      { verb: "GET", path: "/en/pages", handler: handler2 },
+    ]);
+  });
+
+  test("link links local routes with the app", () => {
+    const handler = () => {};
+    adapter.addRoute("GET", "/en/pages", handler);
+
+    adapter.link();
+
+    expect(app.get).toHaveBeenCalledTimes(1);
+    expect(app.get).toHaveBeenCalledWith("/en/pages", handler);
   });
-});
+});

package/src/tests/handlers/TagsHandlerAPI.test/index.test.js

@@ -0,0 +1,38 @@
+import Tags from "../../../cloud/Tags";
+import TagsAPIHandler from "../../../handlers/TagsAPIHandler";
+
+import Factory from "../../support/factory";
+
+describe("Pages API Handler", () => {
+  function buildCtx() {
+    return {
+      client: {
+        tags: new Tags(() => ({}), "token"),
+      },
+      query: { foo: "bar" },
+      locale: "en",
+    };
+  }
+
+  test("index", async () => {
+    const tags = [
+      Factory.build("tag", { id: "1", name: "First Tag" }),
+      Factory.build("tag", { id: "2", name: "Second Tag" }),
+    ];
+
+    const ctx = buildCtx();
+
+    const mockedList = jest
+      .spyOn(ctx.client.tags, "list")
+      .mockImplementation(() => ({ tags: tags }));
+
+    const result = await TagsAPIHandler.index(ctx);
+
+    expect(mockedList).toHaveBeenCalledWith({ foo: "bar" }, "en");
+    expect(result).toEqual({
+      json: {
+        tags: tags,
+      },
+    });
+  });
+});

package/src/tests/handlers/articles/ArticlesAPIHandler.test/index.test.js

@@ -0,0 +1,43 @@
+import Articles from "../../../../cloud/Articles";
+import ArticlesAPIHandler from "../../../../handlers/articles/ArticlesAPIHandler";
+
+import Factory from "../../../support/factory";
+
+describe("Articles API Handler", () => {
+  function buildCtx() {
+    return {
+      client: {
+        articles: new Articles(() => ({}), "token"),
+      },
+      query: { foo: "bar" },
+      locale: "en",
+      resourceConfig: {
+        articleType: "article",
+        articleTypePlural: "articles",
+      },
+    };
+  }
+
+  test("index", async () => {
+    const article = Factory.build("article");
+    const ctx = buildCtx();
+
+    const mockedArticleList = jest
+      .spyOn(ctx.client.articles, "listAll")
+      .mockImplementation(() => ({ list: [article] }));
+
+    const result = await ArticlesAPIHandler.index(ctx);
+
+    expect(mockedArticleList).toHaveBeenCalledWith(
+      { foo: "bar" },
+      "en",
+      "article"
+    );
+
+    expect(result).toEqual({
+      json: {
+        list: [article],
+      },
+    });
+  });
+});

package/src/tests/handlers/articles/ChangeHandler.test/show.test.js

@@ -0,0 +1,59 @@
+import ArticleChanges from "../../../../cloud/ArticleChanges";
+import ArticleRevisions from "../../../../cloud/ArticleRevisions";
+import Articles from "../../../../cloud/Articles";
+import ChangeHandler from "../../../../handlers/articles/ChangeHandler";
+
+import Factory from "../../../support/factory";
+
+describe("ChangeHandler", () => {
+  function buildCtx(article) {
+    return {
+      client: {
+        articles: new Articles(() => ({}), "token"),
+        articleChanges: new ArticleChanges(() => ({}), "token"),
+        articleRevisions: new ArticleRevisions(() => ({}), "token"),
+      },
+      params: { parent_id: article.id },
+      query: { version: 49 },
+      locale: "en",
+      resourceConfig: {
+        articleType: "article",
+        articleTypePlural: "articles",
+      },
+    };
+  }
+
+  test("show for existing article", async () => {
+    const article = Factory.build("article");
+
+    const ctx = buildCtx(article);
+
+    const mockedArticleFind = jest
+      .spyOn(ctx.client.articles, "getChangePreview")
+      .mockImplementation(() => [article]);
+
+    const result = await ChangeHandler.show(ctx);
+
+    expect(mockedArticleFind).toHaveBeenCalledWith(article.id, 49, "en");
+
+    expect(result).toEqual({
+      json: {
+        ...[article],
+      },
+    });
+  });
+
+  test("show for non existing article", async () => {
+    const ctx = buildCtx({ id: "42" });
+
+    const mockedArticleFind = jest
+      .spyOn(ctx.client.articles, "getChangePreview")
+      .mockImplementation(() => null);
+
+    expect(async () => {
+      await ChangeHandler.show(ctx);
+    }).rejects.toThrow("Missing article #42");
+
+    expect(mockedArticleFind).toHaveBeenCalledWith("42", 49, "en");
+  });
+});

package/src/tests/handlers/events/ChangeHandler.test/show.test.js

@@ -0,0 +1,59 @@
+import EventChanges from "../../../../cloud/EventChanges";
+import EventRevisions from "../../../../cloud/EventRevisions";
+import Events from "../../../../cloud/Events";
+import ChangeHandler from "../../../../handlers/events/ChangeHandler";
+
+import Factory from "../../../support/factory";
+
+describe("ChangeHandler", () => {
+  function buildCtx(event) {
+    return {
+      client: {
+        events: new Events(() => ({}), "token"),
+        eventChanges: new EventChanges(() => ({}), "token"),
+        eventRevisions: new EventRevisions(() => ({}), "token"),
+      },
+      params: { parent_id: event.id },
+      query: { version: 49 },
+      locale: "en",
+      resourceConfig: {
+        eventType: "event",
+        eventTypePlural: "events",
+      },
+    };
+  }
+
+  test("show for existing event", async () => {
+    const event = Factory.build("event");
+
+    const ctx = buildCtx(event);
+
+    const mockedEventFind = jest
+      .spyOn(ctx.client.events, "getChangePreview")
+      .mockImplementation(() => [event]);
+
+    const result = await ChangeHandler.show(ctx);
+
+    expect(mockedEventFind).toHaveBeenCalledWith(event.id, 49, "en");
+
+    expect(result).toEqual({
+      json: {
+        ...[event],
+      },
+    });
+  });
+
+  test("show for non existing event", async () => {
+    const ctx = buildCtx({ id: "42" });
+
+    const mockedEventFind = jest
+      .spyOn(ctx.client.events, "getChangePreview")
+      .mockImplementation(() => null);
+
+    expect(async () => {
+      await ChangeHandler.show(ctx);
+    }).rejects.toThrow("Missing event #42");
+
+    expect(mockedEventFind).toHaveBeenCalledWith("42", 49, "en");
+  });
+});

package/src/tests/handlers/events/EventsAPIHandler.test/index.test.js

@@ -0,0 +1,39 @@
+import Events from "../../../../cloud/Events";
+import EventsAPIHandler from "../../../../handlers/events/EventsAPIHandler";
+
+import Factory from "../../../support/factory";
+
+describe("Events API Handler", () => {
+  function buildCtx() {
+    return {
+      client: {
+        events: new Events(() => ({}), "token"),
+      },
+      query: { foo: "bar" },
+      locale: "en",
+      resourceConfig: {
+        eventType: "event",
+        eventTypePlural: "events",
+      },
+    };
+  }
+
+  test("index", async () => {
+    const event = Factory.build("event");
+    const ctx = buildCtx();
+
+    const mockedEventList = jest
+      .spyOn(ctx.client.events, "listAll")
+      .mockImplementation(() => ({ list: [event] }));
+
+    const result = await EventsAPIHandler.index(ctx);
+
+    expect(mockedEventList).toHaveBeenCalledWith({ foo: "bar" }, "en", "event");
+
+    expect(result).toEqual({
+      json: {
+        list: [event],
+      },
+    });
+  });
+});

package/src/tests/handlers/pages/ChangeHandler.test/show.test.js

@@ -0,0 +1,59 @@
+import PageChanges from "../../../../cloud/PageChanges";
+import PageRevisions from "../../../../cloud/PageRevisions";
+import Pages from "../../../../cloud/Pages";
+import ChangeHandler from "../../../../handlers/pages/ChangeHandler";
+
+import Factory from "../../../support/factory";
+
+describe("ChangeHandler", () => {
+  function buildCtx(page) {
+    return {
+      client: {
+        pages: new Pages(() => ({}), "token"),
+        pageChanges: new PageChanges(() => ({}), "token"),
+        pageRevisions: new PageRevisions(() => ({}), "token"),
+      },
+      params: { parent_id: page.id },
+      query: { version: 49 },
+      locale: "en",
+      resourceConfig: {
+        pageType: "page",
+        pageTypePlural: "pages",
+      },
+    };
+  }
+
+  test("show for existing page", async () => {
+    const page = Factory.build("page");
+
+    const ctx = buildCtx(page);
+
+    const mockedPageFind = jest
+      .spyOn(ctx.client.pages, "getChangePreview")
+      .mockImplementation(() => [page]);
+
+    const result = await ChangeHandler.show(ctx);
+
+    expect(mockedPageFind).toHaveBeenCalledWith(page.id, 49, "en");
+
+    expect(result).toEqual({
+      json: {
+        ...[page],
+      },
+    });
+  });
+
+  test("show for non existing page", async () => {
+    const ctx = buildCtx({ id: "42" });
+
+    const mockedPageFind = jest
+      .spyOn(ctx.client.pages, "getChangePreview")
+      .mockImplementation(() => null);
+
+    expect(async () => {
+      await ChangeHandler.show(ctx);
+    }).rejects.toThrow("Missing page #42");
+
+    expect(mockedPageFind).toHaveBeenCalledWith("42", 49, "en");
+  });
+});

package/src/tests/handlers/pages/PagesAPIHandler.test/index.test.js

@@ -0,0 +1,39 @@
+import Pages from "../../../../cloud/Pages";
+import PagesAPIHandler from "../../../../handlers/pages/PagesAPIHandler";
+
+import Factory from "../../../support/factory";
+
+describe("Pages API Handler", () => {
+  function buildCtx() {
+    return {
+      client: {
+        pages: new Pages(() => ({}), "token"),
+      },
+      query: { foo: "bar" },
+      locale: "en",
+      resourceConfig: {
+        pageType: "page",
+        pageTypePlural: "pages",
+      },
+    };
+  }
+
+  test("index", async () => {
+    const page = Factory.build("page");
+    const ctx = buildCtx();
+
+    const mockedPageList = jest
+      .spyOn(ctx.client.pages, "listAll")
+      .mockImplementation(() => ({ list: [page] }));
+
+    const result = await PagesAPIHandler.index(ctx);
+
+    expect(mockedPageList).toHaveBeenCalledWith({ foo: "bar" }, "en", "page");
+
+    expect(result).toEqual({
+      json: {
+        list: [page],
+      },
+    });
+  });
+});

package/src/tests/helpers/AuthHelper.test.js

@@ -49,6 +49,18 @@ describe("AuthHelper", () => {
       const result = AuthHelper.verifyJWT(mockToken);
       expect(result).toBe(false);
     });
+
+    test("returns false for invalid token", () => {
+      const invalidToken = "header";
+      const invalidToken2 = "header.";
+
+      const result = AuthHelper.verifyJWT(invalidToken);
+      expect(result).toBe(false);
+
+      const result2 = AuthHelper.verifyJWT(invalidToken2);
+      expect(result2).toBe(false);
+    })
+
   });
 
   describe("isAuthenticated", () => {