@raketa-cloud/admin 0.0.4 → 0.0.5

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@raketa-cloud/admin",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "main": "src/index.js",
   "scripts": {
-    "dev": "bin/tailwind",
+    "dev": "npx tailwindcss -i ./src/styles/application.css -o ../../apps/admin/static/application.css --watch",
     "test": "jest"
   },
   "devDependencies": {

package/src/Adapter.js

@@ -1,6 +1,11 @@
 const nodePath = require("node:path");
 import { existsSync } from "node:fs";
 import ejs from "ejs";
+import FormBuilder from "./helpers/FormBuilder";
+import HTMLBuilder from "./helpers/HTMLBuilder";
+import form_for from "./helpers/form_for";
+import pagination from "./helpers/pagination_helper";
+import sort_button from "./helpers/sort_button";
 
 function escapeHtml(string) {
   var matchHtmlRegExp = /["'&<>]/;
@@ -66,12 +71,41 @@ const Logger = {
   },
 };
 
+function putIn(result, key, value) {
+  const segments = key.split(/[\[\]]+/).filter(Boolean);
+  let current = result;
+
+  segments.forEach((segment, idx) => {
+    if (idx === segments.length - 1) {
+      current[segment] = value;
+    } else {
+      if (!current[segment]) {
+        current[segment] = {};
+      }
+
+      current = current[segment];
+    }
+  });
+}
+
 export default class Adapter {
   constructor(router) {
     this.router = router;
   }
 
-  createResource(_resource, _mapping) {
+  routeCollection(_resource, _mapping) {
+    throw new Error("Implement in an adapter");
+  }
+
+  routeNestedCollection(_resource, _mapping) {
+    throw new Error("Implement in an adapter");
+  }
+
+  routeMember(_resource, _mapping) {
+    throw new Error("Implement in an adapter");
+  }
+
+  routeNestedMember(_resource, _mapping) {
     throw new Error("Implement in an adapter");
   }
 
@@ -82,17 +116,28 @@ export default class Adapter {
     return existsSync(appPath) ? appPath : packagePath;
   }
 
+  getHelpers() {
+    const t = new HTMLBuilder();
+    const f = new FormBuilder();
+
+    return { t, f, form_for, sort_button, pagination };
+  }
+
   async renderLayout(assigns, body) {
     const layoutTemplate = `${nodePath.dirname(__filename)}/views/layouts/application.ejs`;
-    return await ejs.renderFile(layoutTemplate, { ...assigns, body });
+    return await ejs.renderFile(layoutTemplate, {
+      ...assigns,
+      body,
+    });
   }
 
-  async renderAction({ resource, action, assigns }) {
-    const fullTemplatePath = this.getActionPath(resource, action);
+  async renderAction({ views, action, assigns }) {
+    const fullTemplatePath = this.getActionPath(views, action);
+    const renderAssigns = { ...this.getHelpers(), ...assigns };
 
     try {
-      const rendered = await ejs.renderFile(fullTemplatePath, assigns);
-      const fullPage = await this.renderLayout(assigns, rendered);
+      const rendered = await ejs.renderFile(fullTemplatePath, renderAssigns);
+      const fullPage = await this.renderLayout(renderAssigns, rendered);
 
       return fullPage;
     } catch (e) {
@@ -102,4 +147,14 @@ export default class Adapter {
       return renderError(error, e.stack);
     }
   }
+
+  parseFormBody(body) {
+    const result = {};
+
+    for (const [key, value] of Object.entries(body)) {
+      putIn(result, key, value);
+    }
+
+    return { ...result };
+  }
 }

package/src/HonoAdapter.js

@@ -1,13 +1,60 @@
 import Adapter from "./Adapter";
 import RaketaContext from "./RaketaContext";
+import setupAuthentication from "./setupAuthentication";
+
+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();
+  }
+}
+
+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;
+  }
+}
 
 export default class HonoAdapter extends Adapter {
   constructor(router) {
     super(router);
+    this.globalCtx = (ctx) => ctx;
     this.router = router;
+    this.globalConfig = {};
+
+    // TODO: Pass in a path to redirect to after login?
+    setupAuthentication(router, {
+      remote: {
+        domain: "localhost",
+        host: "http://localhost:3000",
+        cookie_key: "cms-starter-slim",
+      },
+    });
+  }
+
+  setGlobalContext(globalCtx) {
+    this.globalCtx = globalCtx;
+  }
+
+  setGlobalConfig(globalConfigCallback) {
+    globalConfigCallback(this.globalConfig);
   }
 
   async createContext(router, next, verb, resource, action) {
+    const body = await parseBody(router.req);
+
     return new RaketaContext({
       router,
       res: next,
@@ -19,17 +66,21 @@ export default class HonoAdapter extends Adapter {
       url: router.req.url,
       action,
       params: router.req.param(),
-      body: await router.req.parseBody(),
-      query: router.req.query(),
+      body,
+      resourceParams: bodyToParams(router.req, body, this),
+      query: this.formatQuery(router.req.queries()),
       resource,
       assigns: {},
+      authentication: router.get("authentication"),
+      getGlobalCtx: this.globalCtx,
     });
   }
 
-  createAction([
+  async createAction([
     verb,
     path,
     resource,
+    views,
     action,
     handler,
     before_filter,
@@ -37,73 +88,126 @@ export default class HonoAdapter extends Adapter {
   ]) {
     const method = this.getMethod(verb);
 
-    method(path, async (router, next) => {
-      const ctx = await this.createContext(
-        router,
-        next,
-        verb,
-        resource,
-        action
-      );
-
-      console.info(
-        `\x1b[35m[${ctx.method}] ${ctx.rawPath}\x1b[0m -> ${resource}/${action} | ${JSON.stringify(ctx.params)}`
-      );
-
-      const assigns = {
-        beforeFilterAssigns: {},
-        actionAssigns: {},
-        afterFilterAssigns: {},
-      };
-
-      // Process before filters
-      if (before_filter) {
-        const { redirect, assigns: beforeFilterAssigns = {} } =
-          before_filter(ctx) || {};
-
-        if (redirect) return router.redirect(redirect);
-
-        assigns.beforeFilterAssigns = beforeFilterAssigns;
-      }
-
-      // Process action
-      const { redirect, assigns: actionAssigns = {} } = handler(ctx) || {};
-      assigns.actionAssigns = actionAssigns;
-
-      if (redirect) return router.redirect(redirect);
-
-      // Process after filters
-      if (after_filter) {
-        const { redirect, assigns: afterFilterAssigns = {} } =
-          after_filter(ctx) || {};
-
-        if (redirect) return router.redirect(redirect);
-
-        assigns.afterFilterAssigns = afterFilterAssigns;
-      }
-
-      const fullAssigns = {
-        ...ctx.assigns,
-        ...assigns.beforeFilterAssigns,
-        ...assigns.actionAssigns,
-        ...assigns.afterFilterAssigns,
-      };
-
-      const rendered = this.renderAction({
-        resource,
-        action,
-        assigns: fullAssigns,
+    [...Object.keys(this.globalConfig.locales), ""].forEach((currentLocale) => {
+      const completedPath = `/${currentLocale}${path}`;
+
+      method(completedPath, async (routerCtx, next) => {
+        const ctx = await this.createContext(
+          routerCtx,
+          next,
+          verb,
+          resource,
+          action
+        );
+
+        ctx.locales = this.globalConfig.locales;
+        ctx.defaultLocale = this.globalConfig.defaultLocale;
+        ctx.locale = currentLocale;
+
+        const _context = {
+          locales: ctx.locales,
+          locale: ctx.locale,
+          defaultLocale: ctx.defaultLocale,
+          path: ctx.req.path,
+          query: ctx.query || {},
+        };
+
+        console.info(
+          `\x1b[35m[${ctx.method}] ${ctx.rawPath}\x1b[0m -> ${resource}/${action} | ${JSON.stringify(ctx.params)}`
+        );
+
+        const assigns = {
+          beforeFilterAssigns: {},
+          actionAssigns: {},
+          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);
+          }
+
+          assigns.beforeFilterAssigns = beforeFilterAssigns;
+        }
+
+        // Process action
+        const {
+          headers,
+          redirect,
+          json,
+          assigns: actionAssigns = {},
+        } = (await handler(ctx)) || {};
+        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);
+          }
+
+          assigns.afterFilterAssigns = afterFilterAssigns;
+        }
+
+        const fullAssigns = {
+          ...ctx.assigns,
+          ...assigns.beforeFilterAssigns,
+          ...assigns.actionAssigns,
+          ...assigns.afterFilterAssigns,
+          _context: _context,
+        };
+
+        if (json) {
+          return routerCtx.json(json);
+        }
+
+        const rendered = this.renderAction({
+          views,
+          action,
+          assigns: fullAssigns,
+        });
+
+        return routerCtx.html(rendered);
       });
-
-      return router.html(rendered);
     });
   }
 
-  createResource(mapping) {
+  routeCollection(mapping) {
+    mapping.forEach((handlerMap) => this.createAction(handlerMap));
+  }
+
+  routeNestedCollection(mapping) {
+    mapping.forEach((handlerMap) => this.createAction(handlerMap));
+  }
+
+  routeMember(mapping) {
     mapping.forEach((handlerMap) => this.createAction(handlerMap));
   }
 
-  createNestedResource(mapping) {
+  routeNestedMember(mapping) {
     mapping.forEach((handlerMap) => this.createAction(handlerMap));
   }
 
@@ -117,4 +221,28 @@ export default class HonoAdapter extends Adapter {
       }[verb] || this.router.get
     );
   }
+
+  applyHeaders(headers, router) {
+    if (!headers) {
+      return;
+    }
+
+    for (const [key, value] of Object.entries(headers)) {
+      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 };
+  }
 }

package/src/RaketaContext.js

@@ -12,8 +12,11 @@ export default class RaketaContext {
     params,
     query,
     body,
+    resourceParams,
     resource,
     assigns,
+    authentication,
+    getGlobalCtx,
   }) {
     this.router = router;
     this.res = res;
@@ -28,6 +31,16 @@ export default class RaketaContext {
     this.query = query;
     this.body = body;
     this.resource = resource;
+    this.resourceParams = resourceParams;
     this.assigns = assigns;
+    this.authentication = authentication;
+    this.getGlobalCtx = getGlobalCtx;
+  }
+
+  initGlobalContext() {
+    const global = this.getGlobalCtx(this);
+    for (const key in global) {
+      this[key] = global[key];
+    }
   }
 }

package/src/helpers/AuthHelper.js

@@ -0,0 +1,44 @@
+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"];
+
+    if (ALLOWED_PATHS.includes(path)) return true;
+
+    if (token && AuthHelper.verifyJWT(token)) return true;
+
+    return false;
+  },
+
+  getGoogleURL: () => {
+    const {
+      GATEWAY_SOCIAL_AUTH_URL: url,
+      GATEWAY_PROJECT: project,
+      GATEWAY_PRIMARY_USER_POOL: user_pool,
+      ADMIN_LOGIN_CALLBACK_URL: callback_url,
+    } = process.env;
+
+    if ([url, project, user_pool, callback_url].join() === "")
+      throw new Error("Invalid ENVs for authentication configuration");
+
+    return `${url}/${project}/${user_pool}/google?return_to=${callback_url}`;
+  },
+};
+
+export default AuthHelper;