@raketa-cloud/admin 0.0.102 → 1.0.0

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@raketa-cloud/admin",
-  "version": "0.0.102",
+  "version": "1.0.0",
   "main": "src/index.js",
   "files": [
+    "src/",
     "dist/"
   ],
   "scripts": {

package/src/Adapter.js

@@ -0,0 +1,265 @@
+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 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) {
+  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>`;
+};
+
+function toArray(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+
+  return [value].filter(Boolean);
+}
+
+function putIn(result, key, value) {
+  const segments = key.split(/[\[\]]+/).filter(Boolean);
+  let current = result;
+
+  segments.forEach((segment, idx) => {
+    if (idx === segments.length - 1) {
+      if (key.endsWith("[]") || Array.isArray(value)) {
+        current[segment] = toArray(value);
+      } else {
+        current[segment] = value;
+      }
+    } else {
+      if (!current[segment]) {
+        current[segment] = {};
+      }
+
+      current = current[segment];
+    }
+  });
+}
+
+function sanitizePath(filePath) {
+  return path.normalize(path.join(...["/", ...filePath.split("/")]));
+}
+
+function getPartialPath(partialPath, views, viewsFallback) {
+  const packagePath = sanitizePath(
+    `${currentPath}/views/${views}/${partialPath}`
+  );
+
+  const fallbackPackagePath = sanitizePath(
+    `${currentPath}/views/${viewsFallback}/${partialPath}`
+  );
+
+  const appPath = sanitizePath(
+    `${process.cwd()}/src/views/${views}/${partialPath}`
+  );
+
+  if (existsSync(appPath)) {
+    return appPath;
+  }
+
+  if (existsSync(packagePath)) {
+    return packagePath;
+  }
+
+  if (existsSync(fallbackPackagePath)) {
+    return fallbackPackagePath;
+  }
+
+  throw new Error(
+    `Looked for "${partialPath}" in the following places: \n${appPath}\n${packagePath}\n${fallbackPackagePath}\n`
+  );
+}
+
+export default class Adapter {
+  constructor(router) {
+    this.router = router;
+  }
+
+  routeCollection(_resource, _mapping, _resourceConfig) {
+    throw new Error("Implement in an adapter");
+  }
+
+  routeNestedCollection(_resource, _mapping, _resourceConfig) {
+    throw new Error("Implement in an adapter");
+  }
+
+  routeMember(_resource, _mapping, _resourceConfig) {
+    throw new Error("Implement in an adapter");
+  }
+
+  routeNestedMember(_resource, _mapping, _resourceConfig) {
+    throw new Error("Implement in an adapter");
+  }
+
+  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 = {};
+
+    for (const [key, value] of Object.entries(body)) {
+      putIn(result, key, value);
+    }
+
+    return { ...result };
+  }
+}

package/src/HonoAdapter.js

@@ -0,0 +1,269 @@
+import Adapter from "./Adapter";
+import Logger from "./Logger";
+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, config) {
+    super(router);
+    this.globalCtx = (ctx) => ctx;
+    this.router = router;
+    this.globalConfig = config;
+
+    // TODO: Pass in a path to redirect to after login?
+    setupAuthentication(
+      router,
+      config
+    );
+
+    router.get("/", (c) => {
+      return c.redirect("/en");
+    });
+  }
+
+  setGlobalContext(globalCtx) {
+    this.globalCtx = globalCtx;
+  }
+
+  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],
+    resourceConfig
+  ) {
+    const method = this.getMethod(verb);
+
+    Object.keys(this.globalConfig.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;
+      });
+
+      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.locale = currentLocale;
+        ctx.remoteConfig = { ...this.globalConfig.remoteConfig };
+        ctx.logger = Logger;
+
+        const _context = {
+          timezones: this.globalConfig.i18n.timezones,
+          locales: ctx.locales,
+          locale: ctx.locale,
+          defaultLocale: ctx.defaultLocale,
+          path: ctx.req.path,
+          query: ctx.query || {},
+          layout: {
+            ...this.globalConfig.layout,
+          },
+          resourceConfig: resourceConfig,
+          adminJwt: ctx.authentication.token,
+          remoteConfig: { ...this.globalConfig.remoteConfig },
+          globalConfig: this.globalConfig,
+        };
+
+        ctx.logger.info(
+          `${ctx.method} "${ctx.rawPath}" -> ${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, 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);
+          }
+
+          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: views,
+            viewsFallback: resourceConfig.viewsFallback,
+            action,
+            assigns: fullAssigns,
+          },
+          this.globalConfig?.helpers || {}
+        );
+
+        return routerCtx.html(rendered);
+      });
+    });
+  }
+
+  routeCollection(mapping, 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)
+    );
+  }
+
+  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/Logger.js

@@ -0,0 +1,21 @@
+import { inspect } from 'node:util';
+
+
+const dump = (item) => inspect(item, { depth: null }).replace(/^\'/, '').replace(/\'$/, '')
+
+const Logger = {
+  error: (item) => {
+    console.error('[ERROR]', dump(item));
+  },
+
+  info: (item) => {
+    console.info('[INFO]', dump(item));
+  },
+
+  debug: (item) => {
+    console.debug('[DEBUG]', dump(item));
+  },
+}
+
+export default Logger;
+

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/buildResourcePath.js

@@ -0,0 +1,22 @@
+export default function buildResourcePath({
+  prefix_map,
+  resource,
+  resourceType,
+  locale,
+  defaultLocale,
+}) {
+  const prefix = prefix_map[resourceType];
+
+  if (!prefix) {
+    throw new Error(`Unknown resource type: ${resourceType}`);
+  }
+
+  return [
+    locale === defaultLocale ? "" : `/${locale}`,
+    prefix,
+    "/",
+    resource.slug,
+  ]
+    .join("")
+    .replace("//", "/");
+}

package/src/cipher.js

@@ -0,0 +1,49 @@
+import {
+  pbkdf2Sync,
+  createCipheriv,
+  createDecipheriv,
+  randomBytes,
+} from "node:crypto";
+
+const ALGORITHM = "aes-256-cbc";
+const IV = randomBytes(16);
+const SALT = "some string to have a salt value..";
+
+function deriveKey(password) {
+  return pbkdf2Sync(password, SALT, 100000, 32, "sha256");
+}
+
+function encrypt(plaintext, config) {
+  const cipher = createCipheriv(
+    ALGORITHM,
+    deriveKey(config.secrets.crypto_secret),
+    IV
+  );
+
+  let encrypted = cipher.update(plaintext, "utf8", "hex");
+
+  encrypted += cipher.final("hex");
+
+  return `${IV.toString("hex")}:${encrypted}`;
+}
+
+function decrypt(encryptedText, config) {
+  const [ivHex, encrypted] = encryptedText.split(":");
+  const iv = Buffer.from(ivHex, "hex");
+
+  const decipher = createDecipheriv(
+    ALGORITHM,
+    deriveKey(config.secrets.crypto_secret),
+    iv
+  );
+
+  let decrypted = decipher.update(encrypted, "hex", "utf8");
+  decrypted += decipher.final("utf8");
+
+  return decrypted;
+}
+
+export default {
+  encrypt,
+  decrypt,
+};