@raketa-cloud/admin 1.8.4 → 1.8.6

package/src/tests/HonoAdapter.coverage.test.js

@@ -0,0 +1,640 @@
+import { existsSync, readFileSync } from "node:fs";
+import ejs from "ejs";
+
+import HonoAdapter from "../HonoAdapter";
+import Logger from "../Logger";
+import RaketaContext from "../RaketaContext";
+
+jest.mock("node:fs", () => ({
+  existsSync: jest.fn(),
+  readFileSync: jest.fn(),
+}));
+
+jest.mock("ejs", () => ({
+  render: jest.fn(),
+  renderFile: jest.fn(),
+}));
+
+jest.mock("../setupAuthentication", () => jest.fn());
+
+jest.mock("../Logger", () => ({
+  info: jest.fn(),
+  error: jest.fn(),
+}));
+
+function makeRouter() {
+  return {
+    get: jest.fn(),
+    post: jest.fn(),
+    put: jest.fn(),
+    delete: jest.fn(),
+    use: jest.fn(),
+    header: jest.fn(),
+    router: { routes: [] },
+  };
+}
+
+function makeConfig(overrides = {}) {
+  return {
+    i18n: {
+      locales: { en: { name: "English", code: "en-gb" } },
+      defaultLocale: "en",
+      timezones: {},
+      timeLocale: "en-GB",
+      dateTimeFormat: "yyyy-MM-dd HH:mm",
+      dateFormat: "yyyy-MM-dd",
+    },
+    remoteConfig: { foo: "bar" },
+    layout: { sidebar: [] },
+    helpers: {},
+    cloud: { images_api_key: "key" },
+    ...overrides,
+  };
+}
+
+describe("HonoAdapter constructor", () => {
+  test("registers / redirect when config provided", () => {
+    const router = makeRouter();
+    new HonoAdapter(router, makeConfig());
+
+    expect(router.get).toHaveBeenCalledWith("/", expect.any(Function));
+
+    const redirectHandler = router.get.mock.calls.find(
+      ([path]) => path === "/"
+    )[1];
+    const c = { redirect: jest.fn().mockReturnValue("redirected") };
+    expect(redirectHandler(c)).toBe("redirected");
+    expect(c.redirect).toHaveBeenCalledWith("/en");
+  });
+
+  test("does not register / when no config", () => {
+    const router = makeRouter();
+    new HonoAdapter(router);
+
+    expect(router.get).not.toHaveBeenCalled();
+  });
+});
+
+describe("HonoAdapter.getActionPath", () => {
+  let adapter;
+
+  beforeEach(() => {
+    adapter = new HonoAdapter(makeRouter());
+    existsSync.mockReset();
+  });
+
+  test("returns app path when it exists", () => {
+    existsSync.mockReturnValue(true);
+
+    const result = adapter.getActionPath("pages", "pages", "index");
+
+    expect(result).toBe(`${process.cwd()}/src/views/pages/index.ejs`);
+  });
+
+  test("returns package path with viewsFallback when app missing", () => {
+    existsSync.mockReturnValue(false);
+
+    const result = adapter.getActionPath("pages", "fallback", "index");
+
+    expect(result).toContain("/views/fallback/index.ejs");
+  });
+
+  test("returns package path with views when no fallback", () => {
+    existsSync.mockReturnValue(false);
+
+    const result = adapter.getActionPath("pages", null, "index");
+
+    expect(result).toContain("/views/pages/index.ejs");
+  });
+});
+
+describe("HonoAdapter.getHelpers", () => {
+  test("returns helpers object with all keys", () => {
+    const adapter = new HonoAdapter(makeRouter());
+    const helpers = adapter.getHelpers({ remoteConfig: {} });
+
+    expect(helpers).toHaveProperty("t");
+    expect(helpers).toHaveProperty("f");
+    expect(helpers).toHaveProperty("form_for");
+    expect(helpers).toHaveProperty("history");
+    expect(helpers).toHaveProperty("utils");
+    expect(helpers).toHaveProperty("sort_button");
+    expect(helpers).toHaveProperty("pagination");
+    expect(helpers).toHaveProperty("Inflector");
+  });
+});
+
+describe("HonoAdapter.renderPartial", () => {
+  let adapter;
+
+  beforeEach(() => {
+    adapter = new HonoAdapter(makeRouter());
+    existsSync.mockReset();
+    readFileSync.mockReset();
+    ejs.render.mockReset();
+    Logger.error.mockClear();
+  });
+
+  test("renders partial successfully", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue("<%= foo %>");
+    ejs.render.mockReturnValue("rendered");
+
+    const render = adapter.renderPartial({ foo: "bar" }, "pages", null);
+    const result = render("_partial.ejs", { extra: 1 });
+
+    expect(result).toBe("rendered");
+    expect(ejs.render).toHaveBeenCalledWith(
+      "<%= foo %>",
+      expect.objectContaining({ foo: "bar", extra: 1 }),
+      expect.objectContaining({ filename: expect.any(String) })
+    );
+  });
+
+  test("returns error markup on render failure", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockImplementation(() => {
+      const err = new Error("boom");
+      err.stack = "stack-trace";
+      throw err;
+    });
+
+    const render = adapter.renderPartial({}, "pages", null);
+    const result = render("_partial.ejs", {});
+
+    expect(result).toContain("Error rendering");
+    expect(result).toContain("stack-trace");
+    expect(Logger.error).toHaveBeenCalled();
+  });
+
+  test("throws when partial cannot be located", () => {
+    existsSync.mockReturnValue(false);
+
+    const render = adapter.renderPartial({}, "pages", "fallback");
+
+    expect(() => render("_missing.ejs", {})).toThrow(/Template not found/);
+  });
+});
+
+describe("HonoAdapter.renderAction", () => {
+  let adapter;
+
+  beforeEach(() => {
+    adapter = new HonoAdapter(makeRouter(), makeConfig());
+    existsSync.mockReset();
+    readFileSync.mockReset();
+    ejs.render.mockReset();
+    ejs.renderFile.mockReset();
+    Logger.error.mockClear();
+  });
+
+  test("renders action template and layout", async () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue("<%= title %>");
+    ejs.render.mockReturnValue("<h1>Hi</h1>");
+    ejs.renderFile.mockResolvedValue("<html>...</html>");
+
+    const result = await adapter.renderAction({
+      views: "pages",
+      viewsFallback: null,
+      action: "index",
+      assigns: { title: "Hi" },
+    });
+
+    expect(result).toBe("<html>...</html>");
+    expect(ejs.render).toHaveBeenCalled();
+    expect(ejs.renderFile).toHaveBeenCalled();
+  });
+
+  test("returns error markup when action template missing", async () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockImplementation(() => {
+      const err = new Error("nope");
+      err.stack = "trace";
+      throw err;
+    });
+
+    const result = await adapter.renderAction({
+      views: "pages",
+      viewsFallback: null,
+      action: "index",
+      assigns: {},
+    });
+
+    expect(result).toContain("Error rendering");
+    expect(result).toContain("trace");
+    expect(Logger.error).toHaveBeenCalled();
+  });
+});
+
+describe("HonoAdapter.renderLayout", () => {
+  test("calls ejs.renderFile with merged assigns + body", async () => {
+    const adapter = new HonoAdapter(makeRouter());
+    ejs.renderFile.mockReset();
+    ejs.renderFile.mockResolvedValue("<html>ok</html>");
+
+    const result = await adapter.renderLayout({ foo: "bar" }, "<p>body</p>");
+
+    expect(result).toBe("<html>ok</html>");
+    expect(ejs.renderFile).toHaveBeenCalledWith(
+      expect.stringContaining("/views/layouts/application.ejs"),
+      { foo: "bar", body: "<p>body</p>" }
+    );
+  });
+});
+
+describe("HonoAdapter.parseFormBody", () => {
+  test("handles deeply nested keys with mixed string + array values", () => {
+    const adapter = new HonoAdapter(makeRouter());
+
+    const result = adapter.parseFormBody({
+      "user[name]": "Jane",
+      "user[hobbies][]": ["chess", "tennis"],
+    });
+
+    expect(result).toEqual({
+      user: { name: "Jane", hobbies: ["chess", "tennis"] },
+    });
+  });
+
+  test("wraps single-value [] keys into array", () => {
+    const adapter = new HonoAdapter(makeRouter());
+
+    const result = adapter.parseFormBody({
+      "tags[]": "solo",
+    });
+
+    expect(result).toEqual({ tags: ["solo"] });
+  });
+});
+
+describe("HonoAdapter.formatQuery", () => {
+  test("returns empty object for non-object input", () => {
+    const adapter = new HonoAdapter(makeRouter());
+
+    expect(adapter.formatQuery(null)).toEqual({});
+    expect(adapter.formatQuery(undefined)).toEqual({});
+  });
+});
+
+describe("HonoAdapter.createContext", () => {
+  function makeRouterCtx({ req: reqOverrides = {}, ...rest } = {}) {
+    return {
+      req: {
+        header: jest.fn().mockReturnValue("application/json"),
+        json: jest.fn().mockResolvedValue({ foo: "bar" }),
+        text: jest.fn().mockResolvedValue("plain text"),
+        parseBody: jest.fn().mockResolvedValue({}),
+        routePath: "/en/pages",
+        path: "/en/pages",
+        url: "http://localhost/en/pages",
+        param: jest.fn().mockReturnValue({ id: "42" }),
+        queries: jest.fn().mockReturnValue({}),
+        ...reqOverrides,
+      },
+      get: jest.fn().mockReturnValue({ token: "jwt" }),
+      ...rest,
+    };
+  }
+
+  test("creates RaketaContext for json content type", async () => {
+    const adapter = new HonoAdapter(makeRouter(), makeConfig());
+    const routerCtx = makeRouterCtx();
+
+    const ctx = await adapter.createContext(routerCtx, () => {}, "GET", "pages", "index");
+
+    expect(ctx).toBeInstanceOf(RaketaContext);
+    expect(ctx.body).toEqual({ foo: "bar" });
+    expect(ctx.action).toBe("index");
+    expect(ctx.resource).toBe("pages");
+  });
+
+  test("parses text/plain as text", async () => {
+    const adapter = new HonoAdapter(makeRouter(), makeConfig());
+    const routerCtx = makeRouterCtx({
+      req: {
+        header: jest.fn().mockReturnValue("text/plain"),
+      },
+    });
+
+    const ctx = await adapter.createContext(routerCtx, () => {}, "GET", "pages", "index");
+
+    expect(ctx.body).toBe("plain text");
+  });
+
+  test("parses form-urlencoded via parseFormBody", async () => {
+    const adapter = new HonoAdapter(makeRouter(), makeConfig());
+    const formBody = { "user[name]": "Jane" };
+    const routerCtx = makeRouterCtx({
+      req: {
+        header: jest
+          .fn()
+          .mockReturnValue("application/x-www-form-urlencoded"),
+        parseBody: jest.fn().mockResolvedValue(formBody),
+      },
+    });
+
+    const ctx = await adapter.createContext(routerCtx, () => {}, "POST", "pages", "create");
+
+    expect(ctx.resourceParams).toEqual({ user: { name: "Jane" } });
+  });
+
+  test("defaults to parseBody when no content-type header", async () => {
+    const adapter = new HonoAdapter(makeRouter(), makeConfig());
+    const routerCtx = makeRouterCtx({
+      req: {
+        header: jest.fn().mockReturnValue(undefined),
+        parseBody: jest.fn().mockResolvedValue({ raw: "data" }),
+      },
+    });
+
+    const ctx = await adapter.createContext(routerCtx, () => {}, "POST", "pages", "create");
+
+    expect(ctx.body).toEqual({ raw: "data" });
+  });
+});
+
+describe("HonoAdapter.createAction", () => {
+  function makeRouterCtx(overrides = {}) {
+    return {
+      req: {
+        header: jest.fn().mockReturnValue("application/json"),
+        json: jest.fn().mockResolvedValue({}),
+        text: jest.fn().mockResolvedValue(""),
+        parseBody: jest.fn().mockResolvedValue({}),
+        routePath: "/en/pages",
+        path: "/en/pages",
+        url: "http://localhost/en/pages",
+        param: jest.fn().mockReturnValue({}),
+        queries: jest.fn().mockReturnValue({}),
+      },
+      get: jest.fn().mockReturnValue({ token: "jwt" }),
+      redirect: jest.fn().mockReturnValue("redirected"),
+      json: jest.fn().mockReturnValue("jsoned"),
+      text: jest.fn().mockReturnValue("texted"),
+      html: jest.fn().mockReturnValue("htmled"),
+      header: jest.fn(),
+      ...overrides,
+    };
+  }
+
+  function getRegisteredHandler(adapter, path) {
+    return adapter.localRouter.find((r) => r.path === path)?.handler;
+  }
+
+  beforeEach(() => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue("<%= title %>");
+    ejs.render.mockReturnValue("<h1>Hi</h1>");
+    ejs.renderFile.mockResolvedValue("<html>ok</html>");
+  });
+
+  test("registers a route per locale and renders html for assigns result", async () => {
+    const router = makeRouter();
+    const adapter = new HonoAdapter(router, makeConfig());
+    const handler = jest.fn().mockResolvedValue({ assigns: { title: "Hi" } });
+
+    await adapter.createAction(
+      ["GET", "/pages", "pages", "pages", "index", handler],
+      { viewsFallback: "pages" }
+    );
+
+    const registered = getRegisteredHandler(adapter, "/en/pages");
+    expect(registered).toBeDefined();
+
+    const routerCtx = makeRouterCtx();
+    const result = await registered(routerCtx, () => {});
+
+    expect(handler).toHaveBeenCalled();
+    expect(routerCtx.html).toHaveBeenCalled();
+    expect(result).toBe("htmled");
+  });
+
+  test("returns redirect when handler resolves with redirect", async () => {
+    const router = makeRouter();
+    const adapter = new HonoAdapter(router, makeConfig());
+    const handler = jest.fn().mockResolvedValue({ redirect: "/en/pages/1" });
+
+    await adapter.createAction(
+      ["POST", "/pages", "pages", "pages", "create_form", handler],
+      {}
+    );
+
+    const registered = getRegisteredHandler(adapter, "/en/pages");
+    const routerCtx = makeRouterCtx();
+
+    await registered(routerCtx, () => {});
+
+    expect(routerCtx.redirect).toHaveBeenCalledWith("/en/pages/1");
+  });
+
+  test("returns json when handler resolves with json", async () => {
+    const router = makeRouter();
+    const adapter = new HonoAdapter(router, makeConfig());
+    const handler = jest.fn().mockResolvedValue({ json: { ok: true } });
+
+    await adapter.createAction(
+      ["GET", "/api/pages", "pages", "pages", "index", handler],
+      {}
+    );
+
+    const registered = getRegisteredHandler(adapter, "/en/api/pages");
+    const routerCtx = makeRouterCtx();
+
+    await registered(routerCtx, () => {});
+
+    expect(routerCtx.json).toHaveBeenCalledWith({ ok: true });
+  });
+
+  test("returns text when handler resolves with text", async () => {
+    const router = makeRouter();
+    const adapter = new HonoAdapter(router, makeConfig());
+    const handler = jest.fn().mockResolvedValue({ text: "csv,data" });
+
+    await adapter.createAction(
+      ["GET", "/exports", "pages", "pages", "index", handler],
+      {}
+    );
+
+    const registered = getRegisteredHandler(adapter, "/en/exports");
+    const routerCtx = makeRouterCtx();
+
+    await registered(routerCtx, () => {});
+
+    expect(routerCtx.text).toHaveBeenCalledWith("csv,data");
+  });
+
+  test("applies headers from handler result", async () => {
+    const router = makeRouter();
+    const adapter = new HonoAdapter(router, makeConfig());
+    const handler = jest
+      .fn()
+      .mockResolvedValue({ headers: { "X-Test": "1" }, json: {} });
+
+    await adapter.createAction(
+      ["GET", "/pages", "pages", "pages", "index", handler],
+      {}
+    );
+
+    const registered = getRegisteredHandler(adapter, "/en/pages");
+    const routerCtx = makeRouterCtx();
+
+    await registered(routerCtx, () => {});
+
+    expect(routerCtx.header).toHaveBeenCalledWith("X-Test", "1");
+  });
+
+  test("runs beforeFilter and merges assigns when pattern matches", async () => {
+    const router = makeRouter();
+    const adapter = new HonoAdapter(router, makeConfig());
+    adapter.setBeforeFilter(/\/pages/, () => ({ assigns: { before: "yes" } }));
+    const handler = jest.fn().mockResolvedValue({ assigns: {} });
+
+    await adapter.createAction(
+      ["GET", "/pages", "pages", "pages", "index", handler],
+      {}
+    );
+
+    const registered = getRegisteredHandler(adapter, "/en/pages");
+    const routerCtx = makeRouterCtx();
+
+    await registered(routerCtx, () => {});
+
+    expect(handler).toHaveBeenCalled();
+    expect(routerCtx.html).toHaveBeenCalled();
+  });
+
+  test("beforeFilter can short-circuit with redirect", async () => {
+    const router = makeRouter();
+    const adapter = new HonoAdapter(router, makeConfig());
+    adapter.setBeforeFilter(/\/pages/, () => ({ redirect: "/login" }));
+    const handler = jest.fn();
+
+    await adapter.createAction(
+      ["GET", "/pages", "pages", "pages", "index", handler],
+      {}
+    );
+
+    const registered = getRegisteredHandler(adapter, "/en/pages");
+    const routerCtx = makeRouterCtx();
+
+    await registered(routerCtx, () => {});
+
+    expect(routerCtx.redirect).toHaveBeenCalledWith("/login");
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  test("beforeFilter can short-circuit with json", async () => {
+    const router = makeRouter();
+    const adapter = new HonoAdapter(router, makeConfig());
+    adapter.setBeforeFilter(/\/pages/, () => ({ json: { denied: true } }));
+    const handler = jest.fn();
+
+    await adapter.createAction(
+      ["GET", "/pages", "pages", "pages", "index", handler],
+      {}
+    );
+
+    const registered = getRegisteredHandler(adapter, "/en/pages");
+    const routerCtx = makeRouterCtx();
+
+    await registered(routerCtx, () => {});
+
+    expect(routerCtx.json).toHaveBeenCalledWith({ denied: true });
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  test("afterFilter can short-circuit with redirect", async () => {
+    const router = makeRouter();
+    const adapter = new HonoAdapter(router, makeConfig());
+    adapter.setAfterFilter(/\/pages/, () => ({ redirect: "/after" }));
+    const handler = jest.fn().mockResolvedValue({ assigns: {} });
+
+    await adapter.createAction(
+      ["GET", "/pages", "pages", "pages", "index", handler],
+      {}
+    );
+
+    const registered = getRegisteredHandler(adapter, "/en/pages");
+    const routerCtx = makeRouterCtx();
+
+    await registered(routerCtx, () => {});
+
+    expect(routerCtx.redirect).toHaveBeenCalledWith("/after");
+  });
+
+  test("afterFilter can short-circuit with json + text + merges assigns", async () => {
+    const router = makeRouter();
+    const adapter = new HonoAdapter(router, makeConfig());
+    adapter.setAfterFilter(/\/pages/, () => ({ json: { after: true } }));
+    const handler = jest.fn().mockResolvedValue({ assigns: {} });
+
+    await adapter.createAction(
+      ["GET", "/pages", "pages", "pages", "index", handler],
+      {}
+    );
+
+    const registered = getRegisteredHandler(adapter, "/en/pages");
+    const routerCtx = makeRouterCtx();
+
+    await registered(routerCtx, () => {});
+
+    expect(routerCtx.json).toHaveBeenCalledWith({ after: true });
+  });
+
+  test("afterFilter merges assigns when no short-circuit", async () => {
+    const router = makeRouter();
+    const adapter = new HonoAdapter(router, makeConfig());
+    adapter.setAfterFilter(/\/pages/, () => ({ assigns: { after: "yes" } }));
+    const handler = jest.fn().mockResolvedValue({ assigns: { foo: "bar" } });
+
+    await adapter.createAction(
+      ["GET", "/pages", "pages", "pages", "index", handler],
+      {}
+    );
+
+    const registered = getRegisteredHandler(adapter, "/en/pages");
+    const routerCtx = makeRouterCtx();
+
+    await registered(routerCtx, () => {});
+
+    expect(routerCtx.html).toHaveBeenCalled();
+  });
+
+  test("handler returning nullish defaults to empty result + renders html", async () => {
+    const router = makeRouter();
+    const adapter = new HonoAdapter(router, makeConfig());
+    const handler = jest.fn().mockResolvedValue(undefined);
+
+    await adapter.createAction(
+      ["GET", "/pages", "pages", "pages", "index", handler],
+      {}
+    );
+
+    const registered = getRegisteredHandler(adapter, "/en/pages");
+    const routerCtx = makeRouterCtx();
+
+    await registered(routerCtx, () => {});
+
+    expect(routerCtx.html).toHaveBeenCalled();
+  });
+});
+
+describe("HonoAdapter.routeCollection (instance)", () => {
+  test("creates an action per mapping entry", async () => {
+    const adapter = new HonoAdapter(makeRouter(), makeConfig());
+    const createSpy = jest.spyOn(adapter, "createAction").mockResolvedValue();
+
+    const handler = () => {};
+    const mapping = [
+      ["GET", "/a", "a", "a", "index", handler],
+      ["POST", "/a", "a", "a", "create", handler],
+    ];
+
+    adapter.routeCollection(mapping, { viewsFallback: "a" });
+
+    expect(createSpy).toHaveBeenCalledTimes(2);
+    expect(createSpy).toHaveBeenCalledWith(mapping[0], { viewsFallback: "a" });
+    expect(createSpy).toHaveBeenCalledWith(mapping[1], { viewsFallback: "a" });
+  });
+});

package/src/tests/buildResourcePath.test.js

@@ -0,0 +1,69 @@
+import buildResourcePath from "../buildResourcePath";
+
+describe("buildResourcePath", () => {
+  const prefix_map = {
+    page: "/",
+    article: "/blog",
+    event: "/events",
+  };
+
+  test("strips locale when locale matches defaultLocale", () => {
+    const result = buildResourcePath({
+      prefix_map,
+      resource: { slug: "about" },
+      resourceType: "page",
+      locale: "en",
+      defaultLocale: "en",
+    });
+
+    expect(result).toBe("/about");
+  });
+
+  test("prepends locale when not default", () => {
+    const result = buildResourcePath({
+      prefix_map,
+      resource: { slug: "hello" },
+      resourceType: "article",
+      locale: "bg",
+      defaultLocale: "en",
+    });
+
+    expect(result).toBe("/bg/blog/hello");
+  });
+
+  test("works for nested prefix", () => {
+    const result = buildResourcePath({
+      prefix_map,
+      resource: { slug: "summit" },
+      resourceType: "event",
+      locale: "de",
+      defaultLocale: "en",
+    });
+
+    expect(result).toBe("/de/events/summit");
+  });
+
+  test("collapses leading double slash for page resourceType in default locale", () => {
+    const result = buildResourcePath({
+      prefix_map,
+      resource: { slug: "" },
+      resourceType: "page",
+      locale: "en",
+      defaultLocale: "en",
+    });
+
+    expect(result).toBe("/");
+  });
+
+  test("throws when resourceType has no prefix mapping", () => {
+    expect(() =>
+      buildResourcePath({
+        prefix_map,
+        resource: { slug: "foo" },
+        resourceType: "unknown",
+        locale: "en",
+        defaultLocale: "en",
+      })
+    ).toThrow("Unknown resource type: unknown");
+  });
+});