@raketa-cloud/admin 1.6.2 → 1.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raketa-cloud/admin",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "main": "src/index.js",
   "files": [
     "src/",
@@ -18,13 +18,13 @@
     "@repo/typescript-config": "*",
     "@tailwindcss/forms": "0.5.7",
     "@tailwindcss/typography": "0.5.13",
-    "@types/node": "22.15.19",
+    "@types/node": "22.15.21",
     "jest": "29.7.0",
     "tailwindcss": "3.4.4",
     "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/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);
   });
-});
+});