@raketa-cloud/admin 0.0.3 → 0.0.5

package/babel.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  presets: [
+    ["@babel/preset-env", { targets: { node: "current" } }],
+    "@babel/preset-typescript",
+  ],
+};

package/bin/tailwind

@@ -0,0 +1,2 @@
+# npx tailwindcss -i ./src/styles/application.css -o ./dist/application.css --watch
+npx tailwindcss -i ./src/styles/application.css -o ../../apps/admin/static/application.css --watch

package/package.json

@@ -1,32 +1,24 @@
 {
-	"name": "@raketa-cloud/admin",
-	"version": "0.0.3",
-	"private": false,
-	"main": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"files": ["dist"],
-	"scripts": {
-		"build": "tsup src/index.ts --format cjs --loader \".js=jsx\"",
-		"dev": "tsup src/index.ts --format cjs --loader \".js=jsx\" --watch",
-		"lint": "biome lint --apply .",
-		"test": "jest --verbose",
-		"format": "prettier --write ."
-	},
-	"devDependencies": {
-		"@jest/globals": "^29.7.0",
-		"@repo/typescript-config": "*",
-		"@turbo/gen": "^1.11.3",
-		"@types/jest": "^29.5.8",
-		"@types/node": "^20.10.6",
-		"jest": "^29.7.0",
-		"ts-jest": "^29.1.1",
-		"tsup": "6.5.0",
-		"typescript": "^5.3.3"
-	},
-	"dependencies": {
-		"@biomejs/biome": "1.5.3",
-		"graphql-request": "^6.1.0",
-		"hono": "^3.12.3",
-		"prettier": "^3.2.4"
-	}
+  "name": "@raketa-cloud/admin",
+  "version": "0.0.5",
+  "main": "src/index.js",
+  "scripts": {
+    "dev": "npx tailwindcss -i ./src/styles/application.css -o ../../apps/admin/static/application.css --watch",
+    "test": "jest"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.24.7",
+    "@babel/preset-env": "^7.24.7",
+    "@babel/preset-typescript": "^7.24.7",
+    "@repo/typescript-config": "*",
+    "@tailwindcss/forms": "^0.5.7",
+    "@tailwindcss/typography": "^0.5.13",
+    "@types/node": "^20.11.24",
+    "jest": "^29.7.0",
+    "tailwindcss": "^3.4.4",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "ejs": "^3.1.10"
+  }
 }

package/src/Adapter.js

@@ -0,0 +1,160 @@
+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 = /["'&<>]/;
+
+  var str = "" + string;
+  var match = matchHtmlRegExp.exec(str);
+
+  if (!match) {
+    return str;
+  }
+
+  var escape;
+  var html = "";
+  var index = 0;
+  var lastIndex = 0;
+
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34: // "
+        escape = "&quot;";
+        break;
+      case 38: // &
+        escape = "&amp;";
+        break;
+      case 39: // '
+        escape = "&#39;";
+        break;
+      case 60: // <
+        escape = "&lt;";
+        break;
+      case 62: // >
+        escape = "&gt;";
+        break;
+      default:
+        continue;
+    }
+
+    if (lastIndex !== index) {
+      html += str.substring(lastIndex, index);
+    }
+
+    lastIndex = index + 1;
+    html += escape;
+  }
+
+  return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
+}
+
+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>`;
+};
+
+const Logger = {
+  error: (msg) => {
+    console.error(`\x1b[31m🦑 ${msg}\x1b[0m`);
+  },
+};
+
+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;
+  }
+
+  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");
+  }
+
+  getActionPath(resource, action) {
+    const packagePath = `${nodePath.dirname(__filename)}/views/${resource}/${action}.ejs`;
+    const appPath = `${process.cwd()}/src/views/${resource}/${action}.ejs`;
+
+    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,
+    });
+  }
+
+  async renderAction({ views, action, assigns }) {
+    const fullTemplatePath = this.getActionPath(views, action);
+    const renderAssigns = { ...this.getHelpers(), ...assigns };
+
+    try {
+      const rendered = await ejs.renderFile(fullTemplatePath, renderAssigns);
+      const fullPage = await 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 = {};
+
+    for (const [key, value] of Object.entries(body)) {
+      putIn(result, key, value);
+    }
+
+    return { ...result };
+  }
+}

package/src/HonoAdapter.js

@@ -0,0 +1,248 @@
+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,
+      req: router.req,
+      method: verb,
+      headers: router.req.header(),
+      rawPath: router.req.routePath,
+      path: router.req.path,
+      url: router.req.url,
+      action,
+      params: router.req.param(),
+      body,
+      resourceParams: bodyToParams(router.req, body, this),
+      query: this.formatQuery(router.req.queries()),
+      resource,
+      assigns: {},
+      authentication: router.get("authentication"),
+      getGlobalCtx: this.globalCtx,
+    });
+  }
+
+  async createAction([
+    verb,
+    path,
+    resource,
+    views,
+    action,
+    handler,
+    before_filter,
+    after_filter,
+  ]) {
+    const method = this.getMethod(verb);
+
+    [...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);
+      });
+    });
+  }
+
+  routeCollection(mapping) {
+    mapping.forEach((handlerMap) => this.createAction(handlerMap));
+  }
+
+  routeNestedCollection(mapping) {
+    mapping.forEach((handlerMap) => this.createAction(handlerMap));
+  }
+
+  routeMember(mapping) {
+    mapping.forEach((handlerMap) => this.createAction(handlerMap));
+  }
+
+  routeNestedMember(mapping) {
+    mapping.forEach((handlerMap) => this.createAction(handlerMap));
+  }
+
+  getMethod(verb) {
+    return (
+      {
+        GET: this.router.get,
+        POST: this.router.post,
+        PUT: this.router.put,
+        DELETE: this.router.delete,
+      }[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

@@ -0,0 +1,46 @@
+export default class RaketaContext {
+  constructor({
+    router,
+    res,
+    req,
+    method,
+    headers,
+    rawPath,
+    path,
+    url,
+    action,
+    params,
+    query,
+    body,
+    resourceParams,
+    resource,
+    assigns,
+    authentication,
+    getGlobalCtx,
+  }) {
+    this.router = router;
+    this.res = res;
+    this.req = req;
+    this.method = method;
+    this.headers = headers;
+    this.rawPath = rawPath;
+    this.path = path;
+    this.url = url;
+    this.action = action;
+    this.params = params;
+    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;