@raketa-cloud/admin 1.3.0 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raketa-cloud/admin",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "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.24.7",
-    "@babel/preset-env": "7.24.7",
-    "@babel/preset-typescript": "7.24.7",
+    "@babel/core": "7.26.10",
+    "@babel/preset-env": "7.26.9",
+    "@babel/preset-typescript": "7.26.0",
     "@repo/typescript-config": "*",
     "@tailwindcss/forms": "0.5.7",
     "@tailwindcss/typography": "0.5.13",
-    "@types/node": "20.11.24",
+    "@types/node": "22.13.10",
     "jest": "29.7.0",
     "tailwindcss": "3.4.4",
-    "typescript": "5.3.3"
+    "typescript": "5.8.2"
   },
   "dependencies": {
     "ejs": "3.1.10",
-    "graphql-request": "5.1.0"
+    "graphql-request": "7.1.2"
   }
 }

package/src/HonoAdapter.js

@@ -1,51 +1,241 @@
-import Adapter from "./Adapter";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import ejs from "ejs";
 import Logger from "./Logger";
+import currentPath from "./currentPath.cjs";
+import FormBuilder from "./helpers/FormBuilder";
+import HTMLBuilder from "./helpers/HTMLBuilder";
+import Inflector from "./helpers/Inflector";
 import RaketaContext from "./RaketaContext";
 import setupAuthentication from "./setupAuthentication";
+import form_for from "./helpers/form_for";
+import history from "./helpers/historyUtils";
+import pagination from "./helpers/pagination_helper";
+import sort_button from "./helpers/sort_button";
+import utils from "./helpers/utils";
+
+function escapeHtml(string) {
+  const escape = {
+    '"': '"',
+    '&': '&',
+    "'": ''',
+    '<': '&lt;',
+    '>': '&gt;'
+  };
+  
+  return String(string).replace(/["&'<>]/g, char => escape[char]);
+}
+
+const renderError = (message, stack) => {
+  const errorCSS = `
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    html { font-family: sans-serif; font-size: 16px; padding: 2rem; background-color: pink; }
+    h1 { margin-bottom: 1rem; color: FireBrick; }
+    .fail-squid { font-size: 7rem; }
+    pre { padding: 1.5rem 2rem; border-radius: 0.5rem; background-color: black; color: white; line-height: 1.5; font-size: 1.25rem; }
+  `;
+  return `<style>${errorCSS}</style><div class="fail-squid">🦑</div><h1>${message}</h1><pre>${escapeHtml(stack)}</pre>`;
+};
+
+// Convert to array if needed
+const toArray = value => Array.isArray(value) ? value : [value].filter(Boolean);
+
+// Handle nested form values
+function putIn(result, key, value) {
+  const segments = key.split(/[\[\]]+/).filter(Boolean);
+  let current = result;
+
+  segments.forEach((segment, idx) => {
+    const isLastSegment = idx === segments.length - 1;
+    
+    if (isLastSegment) {
+      // Set value at final segment
+      current[segment] = key.endsWith("[]") || Array.isArray(value) 
+        ? toArray(value) 
+        : value;
+    } else {
+      // Create path to next segment
+      current[segment] ??= {};
+      current = current[segment];
+    }
+  });
+}
+
+// Normalize paths for consistent handling
+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}`)
+  ].filter(Boolean);
+  
+  // Return first existing 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')}`);
+}
 
+// Parse request body based on content type
 async function parseBody(req) {
-  switch (req.header("Content-type")) {
-    case "multipart/form-data":
-    case "application/x-www-form-urlencoded":
-      return req.parseBody();
-    case "application/json":
-      return req.json();
-    case "text/plain":
-      return req.text();
-    default:
-      // That is an ok default for now
-      return req.parseBody();
-  }
+  const contentType = req.header("Content-type") || "";
+  
+  if (contentType.includes("json")) return req.json();
+  if (contentType === "text/plain") return req.text();
+  
+  // Default for form data and other content types
+  return req.parseBody();
 }
 
+// Convert body to request parameters
 function bodyToParams(req, parsedBody, adapter) {
-  switch (req.header("Content-type")) {
-    case "multipart/form-data":
-    case "application/x-www-form-urlencoded":
-      return adapter.parseFormBody(parsedBody);
-    default:
-      return parsedBody;
+  const contentType = req.header("Content-type") || "";
+  
+  if (contentType.includes("form-data") || contentType.includes("urlencoded")) {
+    return adapter.parseFormBody(parsedBody);
   }
+  
+  return parsedBody;
 }
 
-export default class HonoAdapter extends Adapter {
+export default class HonoAdapter {
   constructor(router, config) {
-    super(router);
     this.globalCtx = (ctx) => ctx;
     this.router = router;
     this.globalConfig = config;
+    this.globalBeforeFilters = [];
+    this.globalAfterFilters = [];
 
     // TODO: Pass in a path to redirect to after login?
-    setupAuthentication(router, config);
-
-    router.get("/", (c) => {
-      return c.redirect("/en");
-    });
+    if (config) {
+      setupAuthentication(router, config);
+    
+      router.get("/", (c) => {
+        return c.redirect("/en");
+      });
+    }
   }
 
   setGlobalContext(globalCtx) {
     this.globalCtx = globalCtx;
   }
+  
+  setBeforeFilter(pattern, filter) {
+    this.globalBeforeFilters.push({ pattern, filter });
+  }
+  
+  setAfterFilter(pattern, filter) {
+    this.globalAfterFilters.push({ pattern, filter });
+  }
+
+  getActionPath(views, viewsFallback, action) {
+    const packagePath = viewsFallback
+      ? `${currentPath}/views/${viewsFallback}/${action}.ejs`
+      : `${currentPath}/views/${views}/${action}.ejs`;
+
+    const appPath = `${process.cwd()}/src/views/${views}/${action}.ejs`;
+
+    return existsSync(appPath) ? appPath : packagePath;
+  }
+
+  getHelpers(viewHelpersConfig) {
+    const t = new HTMLBuilder();
+    const f = new FormBuilder();
+
+    return {
+      t,
+      f,
+      form_for: form_for(viewHelpersConfig),
+      history,
+      utils,
+      sort_button,
+      pagination,
+      Inflector,
+    };
+  }
+
+  async renderLayout(assigns, body) {
+    const layoutTemplate = `${currentPath}/views/layouts/application.ejs`;
+
+    return await ejs.renderFile(layoutTemplate, {
+      ...assigns,
+      body,
+    });
+  }
+
+  renderPartial(assigns, views, viewsFallback) {
+    return function render(relativePath, localAssigns) {
+      const partialPath = getPartialPath(relativePath, views, viewsFallback);
+
+      try {
+        // Synchronously read the partial file as ejs does not support async/await
+        const partialTemplate = readFileSync(partialPath, "utf8");
+        const rendered = ejs.render(
+          partialTemplate,
+          {
+            ...assigns,
+            ...localAssigns,
+          },
+          { filename: partialPath }
+        );
+
+        return rendered;
+      } catch (e) {
+        const error = `Error rendering:\n ${partialPath}`;
+        Logger.error(`${error}\n\n${e.stack}`);
+
+        return renderError(error, e.stack);
+      }
+    };
+  }
+
+  async renderAction(
+    { views, viewsFallback, action, assigns },
+    viewHelpersConfig = {}
+  ) {
+    // Pick the parent here in the views so we can reuse stuff...
+    const fullTemplatePath = this.getActionPath(views, viewsFallback, action);
+    const renderAssigns = { ...this.getHelpers(viewHelpersConfig), ...assigns };
+    const renderPartialHelper = this.renderPartial(
+      renderAssigns,
+      views,
+      viewsFallback
+    );
+
+    try {
+      // Synchronously read the full template file
+      const template = readFileSync(fullTemplatePath, "utf8");
+
+      // Render the full template with synchronous partial rendering
+      const rendered = ejs.render(
+        template,
+        {
+          ...renderAssigns,
+          render_partial: renderPartialHelper,
+        },
+        { filename: fullTemplatePath }
+      );
+
+      const fullPage = this.renderLayout(renderAssigns, rendered);
+
+      return fullPage;
+    } catch (e) {
+      const error = `Error rendering:\n ${fullTemplatePath}`;
+      Logger.error(`${error}\n\n${e.stack}`);
+
+      return renderError(error, e.stack);
+    }
+  }
+
+  parseFormBody(body) {
+    const result = {};
+    Object.entries(body).forEach(([key, value]) => putIn(result, key, value));
+    return result;
+  }
 
   async createContext(router, next, verb, resource, action) {
     const body = await parseBody(router.req);
@@ -71,198 +261,144 @@ export default class HonoAdapter extends Adapter {
     });
   }
 
-  async createAction(
-    [verb, path, resource, views, action, handler, before_filter, after_filter],
-    resourceConfig
-  ) {
+  async createAction([verb, path, resource, views, action, handler], resourceConfig) {
     const method = this.getMethod(verb);
-
-    Object.keys(this.globalConfig.i18n.locales).forEach((currentLocale) => {
+    const { i18n } = this.globalConfig;
+    
+    Object.keys(i18n.locales).forEach((currentLocale) => {
       const completePath = `/${currentLocale}${path}`;
-
-      // A terrible, terrible hack...
-      // So how do we override for the entire handler.. do we need to completely override it, or just partially? Fun stuff?
-      this.router.router.routes = this.router.router.routes.filter((route) => {
-        return route[0] !== verb || route[1] !== completePath;
-      });
+      
+      // Clean up existing routes with same path/verb
+      this.router.router.routes = this.router.router.routes.filter(route => 
+        route[0] !== verb || route[1] !== completePath
+      );
 
       method(completePath, async (routerCtx, next) => {
-        const ctx = await this.createContext(
-          routerCtx,
-          next,
-          verb,
-          resource,
-          action
-        );
-
-        ctx.resourceConfig = resourceConfig;
-        ctx.locales = this.globalConfig.i18n.locales;
-        ctx.defaultLocale = this.globalConfig.i18n.defaultLocale;
-        ctx.maxOpenRevisions = this.globalConfig?.maxOpenRevisions || 3;
-        ctx.locale = currentLocale;
-        ctx.remoteConfig = { ...this.globalConfig.remoteConfig };
-        ctx.logger = Logger;
+        // Create context with request data
+        const ctx = await this.createContext(routerCtx, next, verb, resource, action);
+        
+        // Set context properties
+        Object.assign(ctx, {
+          resourceConfig,
+          locales: i18n.locales,
+          defaultLocale: i18n.defaultLocale,
+          maxOpenRevisions: this.globalConfig?.maxOpenRevisions || 3,
+          locale: currentLocale,
+          remoteConfig: { ...this.globalConfig.remoteConfig },
+          logger: Logger
+        });
 
+        // Build context object
         const _context = {
-          timezones: this.globalConfig.i18n.timezones,
+          timezones: i18n.timezones,
           locales: ctx.locales,
           locale: ctx.locale,
-          defaultLocale: ctx.defaultLocale,
+          defaultLocale: ctx.defaultLocale, 
           maxOpenRevisions: ctx.maxOpenRevisions,
           path: ctx.req.path,
           query: ctx.query || {},
-          layout: {
-            ...this.globalConfig.layout,
-          },
-          resourceConfig: resourceConfig,
-          adminJwt: ctx.authentication.token,
+          layout: { ...this.globalConfig.layout },
+          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
         ctx.initGlobalContext();
 
-        // Process before filters
-        if (before_filter) {
-          const {
-            redirect,
-            json,
-            assigns: beforeFilterAssigns = {},
-          } = before_filter(ctx) || {};
-
-          if (redirect) return routerCtx.redirect(redirect);
-
-          if (json) {
-            return routerCtx.json(json);
+        // Process global before filters
+        for (const { pattern, filter } of this.globalBeforeFilters) {
+          if (pattern.test(ctx.path)) {
+            const result = filter(ctx) || {};
+            
+            if (result.redirect) return routerCtx.redirect(result.redirect);
+            if (result.json) return routerCtx.json(result.json);
+            
+            Object.assign(assigns.beforeFilterAssigns, result.assigns || {});
           }
-
-          assigns.beforeFilterAssigns = beforeFilterAssigns;
         }
 
-        // Process action
-        const {
-          headers,
-          redirect,
-          json,
-          assigns: actionAssigns = {},
-        } = (await handler(ctx, resourceConfig)) || {};
-        assigns.actionAssigns = actionAssigns;
-
-        this.applyHeaders(headers, routerCtx);
-
-        if (redirect) return routerCtx.redirect(redirect);
-
-        // Process after filters
-        if (after_filter) {
-          const {
-            redirect,
-            json,
-            assigns: afterFilterAssigns = {},
-          } = after_filter(ctx) || {};
-
-          if (redirect) return routerCtx.redirect(redirect);
-
-          if (json) {
-            return routerCtx.json(json);
+        // Process action handler
+        const result = await handler(ctx, resourceConfig) || {};
+        assigns.actionAssigns = result.assigns || {};
+        
+        if (result.headers) this.applyHeaders(result.headers, routerCtx);
+        if (result.redirect) return routerCtx.redirect(result.redirect);
+        if (result.json) return routerCtx.json(result.json);
+
+        // Process global after filters
+        for (const { pattern, filter } of this.globalAfterFilters) {
+          if (pattern.test(ctx.path)) {
+            const afterResult = filter(ctx) || {};
+            
+            if (afterResult.redirect) return routerCtx.redirect(afterResult.redirect);
+            if (afterResult.json) return routerCtx.json(afterResult.json);
+            
+            Object.assign(assigns.afterFilterAssigns, afterResult.assigns || {});
           }
-
-          assigns.afterFilterAssigns = afterFilterAssigns;
         }
 
+        // Merge all assigns
         const fullAssigns = {
           ...ctx.assigns,
           ...assigns.beforeFilterAssigns,
           ...assigns.actionAssigns,
           ...assigns.afterFilterAssigns,
-          _context: _context,
+          _context
         };
 
-        if (json) {
-          return routerCtx.json(json);
-        }
-
-        const rendered = this.renderAction(
-          {
-            views: views,
-            viewsFallback: resourceConfig.viewsFallback,
-            action,
-            assigns: fullAssigns,
-          },
-          this.globalConfig?.helpers || {}
-        );
+        // Render the view
+        const rendered = this.renderAction({
+          views,
+          viewsFallback: resourceConfig.viewsFallback,
+          action,
+          assigns: fullAssigns
+        }, this.globalConfig?.helpers || {});
 
         return routerCtx.html(rendered);
       });
     });
   }
 
+  // Single method to handle all route types
   routeCollection(mapping, resourceConfig) {
-    mapping.forEach((handlerMap) =>
-      this.createAction(handlerMap, resourceConfig)
-    );
+    mapping.forEach(handlerMap => this.createAction(handlerMap, resourceConfig));
   }
 
-  routeNestedCollection(mapping, resourceConfig) {
-    mapping.forEach((handlerMap) =>
-      this.createAction(handlerMap, resourceConfig)
-    );
-  }
-
-  routeMember(mapping, resourceConfig) {
-    mapping.forEach((handlerMap) =>
-      this.createAction(handlerMap, resourceConfig)
-    );
-  }
-
-  routeNestedMember(mapping, resourceConfig) {
-    mapping.forEach((handlerMap) =>
-      this.createAction(handlerMap, resourceConfig)
-    );
-  }
+  // Use the same implementation for all route types
+  routeNestedCollection = this.routeCollection;
+  routeMember = this.routeCollection;
+  routeNestedMember = this.routeCollection;
 
   getMethod(verb) {
-    return (
-      {
-        GET: this.router.get,
-        POST: this.router.post,
-        PUT: this.router.put,
-        DELETE: this.router.delete,
-      }[verb] || this.router.get
-    );
+    const methods = {
+      GET: this.router.get,
+      POST: this.router.post,
+      PUT: this.router.put,
+      DELETE: this.router.delete,
+    };
+    return methods[verb] || this.router.get;
   }
 
   applyHeaders(headers, router) {
-    if (!headers) {
-      return;
-    }
-
-    for (const [key, value] of Object.entries(headers)) {
-      router.header(key, value);
-    }
+    if (!headers) return;
+    Object.entries(headers).forEach(([key, value]) => router.header(key, value));
   }
 
   formatQuery(queries) {
     const result = {};
-
-    for (const [key, value] of Object.entries(queries)) {
-      if (value.length === 1) {
-        result[key] = value[0];
-      } else {
-        result[key] = value;
-      }
-    }
-
-    return { ...result };
+    Object.entries(queries).forEach(([key, value]) => {
+      result[key] = value.length === 1 ? value[0] : value;
+    });
+    return result;
   }
-}
+}

package/src/filters.js

@@ -0,0 +1,17 @@
+/**
+ * Sets a global filter to be applied to routes matching the pattern
+ * @param {HonoAdapter} adapter - The adapter instance
+ * @param {RegExp} pattern - Route pattern to match
+ * @param {Function} filter - The filter function
+ */
+export const setBeforeFilter = (adapter, pattern, filter) => 
+  adapter.setBeforeFilter(pattern, filter);
+
+/**
+ * Sets a global after filter to be applied to routes matching the pattern
+ * @param {HonoAdapter} adapter - The adapter instance
+ * @param {RegExp} pattern - Route pattern to match
+ * @param {Function} filter - The filter function
+ */
+export const setAfterFilter = (adapter, pattern, filter) => 
+  adapter.setAfterFilter(pattern, filter);

package/src/index.js

@@ -12,6 +12,7 @@ export { default as setupCloud } from "./setupCloud";
 export { default as routeStandard } from "./routeStandard";
 export { default as routeCategoriesModule } from "./routeCategoriesModule";
 export { default as buildResourcePath } from "./buildResourcePath";
+export { setBeforeFilter, setAfterFilter } from "./filters";
 
 export { default as RaketaClient } from "./cloud/RaketaClient";
 export { default as Redirects } from "./cloud/Redirects";