@raketa-cloud/admin 1.2.0 → 1.4.0

package/src/handlers/pages/PagesHandler.js

@@ -25,7 +25,18 @@ const show = async (ctx) => {
   }
 
   const revisions = await ctx.client.pageRevisions.all(id, ctx.locale);
-  const changes = await ctx.client.pageChanges.list({}, id, ctx.locale);
+  const changes = await ctx.client.pageChanges.list(
+    {
+      "f:change_type": [
+        "revision_publish",
+        "revision_lock",
+        "revision_unlock",
+        "update",
+      ],
+    },
+    id,
+    ctx.locale
+  );
 
   return {
     assigns: {

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";

package/src/routeCollection.js

@@ -1,89 +1,20 @@
 const routeCollection = (adapter, resource, handler, resourceConfig = {}) => {
-  const {
-    before_filter,
-    after_filter,
-    index,
-    show,
-    create_form,
-    edit_form,
-    create,
-    update,
-    destroy,
-  } = handler;
-
-  const mapping = [
-    [
-      "GET",
-      `/${resource}`,
-      resource,
-      resource,
-      "index",
-      index,
-      before_filter,
-      after_filter,
-    ],
-    [
-      "GET",
-      `/${resource}/new`,
-      resource,
-      resource,
-      "create_form",
-      create_form,
-      before_filter,
-      after_filter,
-    ],
-    [
-      "GET",
-      `/${resource}/:id`,
-      resource,
-      resource,
-      "show",
-      show,
-      before_filter,
-      after_filter,
-    ],
-    [
-      "GET",
-      `/${resource}/:id/edit`,
-      resource,
-      resource,
-      "edit_form",
-      edit_form,
-      before_filter,
-      after_filter,
-    ],
-    [
-      "POST",
-      `/${resource}`,
-      resource,
-      resource,
-      "create_form",
-      create,
-      before_filter,
-      after_filter,
-    ],
-    [
-      "POST",
-      `/${resource}/:id`,
-      resource,
-      resource,
-      "edit_form",
-      update,
-      before_filter,
-      after_filter,
-    ],
-    [
-      "DELETE",
-      `/${resource}/:id`,
-      resource,
-      resource,
-      "destroy",
-      destroy,
-      before_filter,
-      after_filter,
-    ],
+  // Create route definitions
+  const routes = [
+    ["GET",    `/${resource}`,         "index",      handler.index],
+    ["GET",    `/${resource}/new`,     "create_form", handler.create_form],
+    ["GET",    `/${resource}/:id`,     "show",       handler.show],
+    ["GET",    `/${resource}/:id/edit`, "edit_form",  handler.edit_form],
+    ["POST",   `/${resource}`,         "create_form", handler.create],
+    ["POST",   `/${resource}/:id`,     "edit_form",  handler.update],
+    ["DELETE", `/${resource}/:id`,     "destroy",    handler.destroy]
   ];
 
+  // Map routes to full configuration
+  const mapping = routes.map(([verb, path, action, fn]) => [
+    verb, path, resource, resource, action, fn
+  ]);
+
   adapter.routeCollection(mapping, resourceConfig);
 };
 

package/src/routeMember.js

@@ -1,39 +1,16 @@
 const routeMember = (adapter, resource, handler, resourceConfig = {}) => {
-  const { before_filter, after_filter, show, edit_form, update } = handler;
-
-  const mapping = [
-    [
-      "GET",
-      `/${resource}`,
-      resource,
-      resource,
-      "show",
-      show,
-      before_filter,
-      after_filter,
-    ],
-    [
-      "GET",
-      `/${resource}/edit`,
-      resource,
-      resource,
-      "edit_form",
-      edit_form,
-      before_filter,
-      after_filter,
-    ],
-    [
-      "POST",
-      `/${resource}`,
-      resource,
-      resource,
-      "edit_form",
-      update,
-      before_filter,
-      after_filter,
-    ],
+  // Create route definitions
+  const routes = [
+    ["GET",  `/${resource}`,       "show",      handler.show],
+    ["GET",  `/${resource}/edit`,  "edit_form", handler.edit_form],
+    ["POST", `/${resource}`,       "edit_form", handler.update]
   ];
 
+  // Map routes to full configuration
+  const mapping = routes.map(([verb, path, action, fn]) => [
+    verb, path, resource, resource, action, fn
+  ]);
+
   adapter.routeMember(mapping, resourceConfig);
 };
 

package/src/routeNestedCollection.js

@@ -1,93 +1,65 @@
-const routeNestedCollection = (
-  adapter,
-  parent,
-  resource,
-  handler,
-  resourceConfig = {}
-) => {
-  const {
-    before_filter,
-    after_filter,
-    index,
-    show,
-    create_form,
-    edit_form,
-    create,
-    update,
-    destroy,
-  } = handler;
+const routeNestedCollection = (adapter, parent, resource, handler, resourceConfig = {}) => {
+  const views = `${parent}/${resource}`;
 
+  // Define routes exactly as they were in the original implementation
+  // to maintain compatibility with the tests
   const mapping = [
     [
       "GET",
       `/${parent}/:parent_id/${resource}`,
       resource,
-      `${parent}/${resource}`,
+      views,
       "index",
-      index,
-      before_filter,
-      after_filter,
+      handler.index
     ],
     [
       "GET",
       `/${parent}/:parent_id/${resource}/new`,
       resource,
-      `${parent}/${resource}`,
+      views,
       "create_form",
-      create_form,
-      before_filter,
-      after_filter,
+      handler.create_form
     ],
     [
       "GET",
       `/${resource}/:id`,
       resource,
-      `${parent}/${resource}`,
+      views,
       "show",
-      show,
-      before_filter,
-      after_filter,
+      handler.show
     ],
     [
       "GET",
       `/${resource}/:id/edit`,
       resource,
-      `${parent}/${resource}`,
+      views,
       "edit_form",
-      edit_form,
-      before_filter,
-      after_filter,
+      handler.edit_form
     ],
     [
       "POST",
       `/${parent}/:parent_id/${resource}`,
       resource,
-      `${parent}/${resource}`,
+      views,
       "create_form",
-      create,
-      before_filter,
-      after_filter,
+      handler.create
     ],
     [
       "PUT",
       `/${resource}/:id`,
       resource,
-      `${parent}/${resource}`,
+      views,
       "update",
-      update,
-      before_filter,
-      after_filter,
+      handler.update
     ],
     [
       "DELETE",
       `/${resource}/:id`,
       resource,
-      `${parent}/${resource}`,
+      views,
       "destroy",
-      destroy,
-      before_filter,
-      after_filter,
-    ],
+      handler.destroy
+    ]
   ];
 
   adapter.routeNestedCollection(mapping, resourceConfig);

package/src/routeNestedMember.js

@@ -1,45 +1,19 @@
-const routeNestedMember = (
-  adapter,
-  parent,
-  resource,
-  handler,
-  resourceConfig = {}
-) => {
-  const { before_filter, after_filter, show, edit_form, update } = handler;
-
-  const mapping = [
-    [
-      "GET",
-      `/${parent}/:parent_id/${resource}`,
-      resource,
-      `${parent}/${resource}`,
-      "show",
-      show,
-      before_filter,
-      after_filter,
-    ],
-    [
-      "GET",
-      `/${parent}/:parent_id/${resource}/edit`,
-      resource,
-      `${parent}/${resource}`,
-      "edit_form",
-      edit_form,
-      before_filter,
-      after_filter,
-    ],
-    [
-      "POST",
-      `/${parent}/:parent_id/${resource}`,
-      resource,
-      `${parent}/${resource}`,
-      "edit_form",
-      update,
-      before_filter,
-      after_filter,
-    ],
+const routeNestedMember = (adapter, parent, resource, handler, resourceConfig = {}) => {
+  const views = `${parent}/${resource}`;
+  const basePath = `/${parent}/:parent_id/${resource}`;
+  
+  // Create route definitions
+  const routes = [
+    ["GET",  basePath,         "show",      handler.show],
+    ["GET",  `${basePath}/edit`, "edit_form", handler.edit_form],
+    ["POST", basePath,         "edit_form", handler.update]
   ];
 
+  // Map routes to full configuration
+  const mapping = routes.map(([verb, path, action, fn]) => [
+    verb, path, resource, views, action, fn
+  ]);
+
   adapter.routeNestedMember(mapping, resourceConfig);
 };
 

package/src/tests/Adapter.test.js

@@ -1,8 +1,8 @@
-import Adapter from "../Adapter";
+import HonoAdapter from "../HonoAdapter";
 
-const adapter = new Adapter({});
+const adapter = new HonoAdapter({});
 
-describe("Adapter", () => {
+describe("HonoAdapter parseFormBody", () => {
   test("parseFormBody returns an object with parsed keys", () => {
     expect(
       adapter.parseFormBody({
@@ -36,4 +36,4 @@ describe("Adapter", () => {
       },
     });
   });
-});
+});

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

@@ -0,0 +1,40 @@
+import HonoAdapter from "../HonoAdapter";
+
+jest.mock("../setupAuthentication", () => jest.fn());
+
+describe("HonoAdapter Global Filters", () => {
+  let adapter;
+  
+  beforeEach(() => {
+    adapter = new HonoAdapter({
+      get: jest.fn(), post: jest.fn(), put: jest.fn(), delete: jest.fn(),
+      router: { routes: [] }
+    }, {
+      i18n: { locales: { en: "English" }, defaultLocale: "en", timezones: {} },
+      remoteConfig: {},
+      layout: {}
+    });
+  });
+  
+  test("setBeforeFilter adds filters to the globalBeforeFilters array", () => {
+    expect(adapter.globalBeforeFilters).toEqual([]);
+    
+    const pattern = /\/settings\/content/;
+    const filter = () => ({ assigns: { foo: "bar" } });
+    
+    adapter.setBeforeFilter(pattern, filter);
+    
+    expect(adapter.globalBeforeFilters).toEqual([{ pattern, filter }]);
+  });
+  
+  test("setAfterFilter adds filters to the globalAfterFilters array", () => {
+    expect(adapter.globalAfterFilters).toEqual([]);
+    
+    const pattern = /\/settings\/content/;
+    const filter = () => ({ assigns: { foo: "bar" } });
+    
+    adapter.setAfterFilter(pattern, filter);
+    
+    expect(adapter.globalAfterFilters).toEqual([{ pattern, filter }]);
+  });
+});

package/src/tests/HonoAdapter.test.js

@@ -1,17 +1,29 @@
 import HonoAdapter from "../HonoAdapter";
 
 class HonoMock {
-  use() {}
-  get() {}
-  post() {}
-  put() {}
-  delete() {}
+  constructor() {
+    this.router = {
+      routes: []
+    };
+    this.get = jest.fn();
+    this.post = jest.fn();
+    this.put = jest.fn();
+    this.delete = jest.fn();
+    this.use = jest.fn();
+    this.header = jest.fn();
+  }
 }
 
-const app = new HonoMock();
-const adapter = new HonoAdapter(app);
-
 describe("HonoAdapter", () => {
+  let app;
+  let adapter;
+  
+  beforeEach(() => {
+    app = new HonoMock();
+    adapter = new HonoAdapter(app);
+  });
+  
+  // Method tests
   test("getMethod returns Hono's get for invalid verbs", () => {
     expect(adapter.getMethod("not existing")).toBe(app.get);
   });
@@ -31,4 +43,93 @@ describe("HonoAdapter", () => {
   test("getMethod for DELETE", () => {
     expect(adapter.getMethod("DELETE")).toBe(app.delete);
   });
-});
+
+  // Form body parsing tests
+  test("parseFormBody returns an object with parsed keys", () => {
+    expect(
+      adapter.parseFormBody({
+        "order[email]": "john@example.com",
+        "order[uid]": "order-id",
+        "order[vouchers]": ["42", 420],
+        "order[items][1][name]": "A beer",
+        "order[items][1][price]": 5,
+        "order[items][1][qty]": 3,
+        "order[items][2][name]": "A t-shirt",
+        "order[items][2][price]": 20,
+        "order[items][2][qty]": 1,
+      })
+    ).toEqual({
+      order: {
+        email: "john@example.com",
+        uid: "order-id",
+        vouchers: ["42", 420],
+        items: {
+          1: {
+            name: "A beer",
+            price: 5,
+            qty: 3,
+          },
+          2: {
+            name: "A t-shirt",
+            price: 20,
+            qty: 1,
+          },
+        },
+      },
+    });
+  });
+  
+  test("setGlobalContext sets the global context function", () => {
+    const newCtx = () => ({ test: true });
+    adapter.setGlobalContext(newCtx);
+    expect(adapter.globalCtx).toBe(newCtx);
+  });
+  
+  test("applyHeaders applies headers to router context", () => {
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Custom-Header": "test-value"
+    };
+    
+    adapter.applyHeaders(headers, app);
+    
+    expect(app.header).toHaveBeenCalledTimes(2);
+    expect(app.header).toHaveBeenCalledWith("Content-Type", "application/json");
+    expect(app.header).toHaveBeenCalledWith("X-Custom-Header", "test-value");
+  });
+  
+  test("applyHeaders does nothing when headers is undefined", () => {
+    adapter.applyHeaders(undefined, app);
+    expect(app.header).not.toHaveBeenCalled();
+  });
+  
+  test("formatQuery formats query parameters correctly", () => {
+    const queries = {
+      single: ["value"],
+      multiple: ["one", "two"]
+    };
+    
+    const result = adapter.formatQuery(queries);
+    
+    expect(result).toEqual({
+      single: "value",
+      multiple: ["one", "two"]
+    });
+  });
+
+  test("parseFormBody handles array values", () => {
+    expect(
+      adapter.parseFormBody({
+        "tags[]": ["javascript", "react", "node"]
+      })
+    ).toEqual({
+      tags: ["javascript", "react", "node"]
+    });
+  });
+
+  test("parseFormBody handles empty values", () => {
+    expect(
+      adapter.parseFormBody({})
+    ).toEqual({});
+  });
+});

package/src/tests/RaketaContext.test.js

@@ -0,0 +1,65 @@
+import RaketaContext from "../RaketaContext";
+
+describe("RaketaContext", () => {
+  test("constructor should initialize all properties", () => {
+    const params = {
+      router: { fake: "router" },
+      res: { fake: "res" },
+      req: { fake: "req" },
+      method: "GET",
+      headers: { "content-type": "application/json" },
+      rawPath: "/raw/path",
+      path: "/path",
+      url: "http://example.com/path",
+      action: "index",
+      params: { id: "123" },
+      query: { sort: "name" },
+      body: { title: "Test" },
+      resourceParams: { resource: { title: "Test" } },
+      resource: "articles",
+      assigns: { someVar: "value" },
+      authentication: { token: "jwt-token" },
+      getGlobalCtx: () => ({}),
+    };
+
+    const context = new RaketaContext(params);
+
+    // Test that all properties are set correctly
+    Object.keys(params).forEach((key) => {
+      expect(context[key]).toEqual(params[key]);
+    });
+  });
+
+  test("initGlobalContext should merge global context into the instance", () => {
+    const globalCtx = jest.fn().mockReturnValue({
+      client: { users: "usersClient" },
+      config: { someConfig: true },
+    });
+
+    const context = new RaketaContext({
+      router: {},
+      res: {},
+      req: {},
+      method: "GET",
+      headers: {},
+      rawPath: "",
+      path: "",
+      url: "",
+      action: "",
+      params: {},
+      query: {},
+      body: {},
+      resourceParams: {},
+      resource: "",
+      assigns: {},
+      authentication: {},
+      getGlobalCtx: globalCtx,
+    });
+
+    context.initGlobalContext();
+
+    expect(globalCtx).toHaveBeenCalledWith(context);
+    expect(context.client).toEqual({ users: "usersClient" });
+    expect(context.config).toEqual({ someConfig: true });
+  });
+});

package/src/tests/cipher.test.js

@@ -0,0 +1,73 @@
+import cipher from "../cipher";
+import { randomBytes } from "node:crypto";
+
+jest.mock("node:crypto", () => {
+  const originalModule = jest.requireActual("node:crypto");
+  
+  // Mock implementation to make tests deterministic
+  const mockIV = Buffer.from("0123456789abcdef0123456789abcdef", "hex");
+  
+  return {
+    ...originalModule,
+    randomBytes: jest.fn(() => mockIV),
+    createCipheriv: originalModule.createCipheriv,
+    createDecipheriv: originalModule.createDecipheriv,
+    pbkdf2Sync: originalModule.pbkdf2Sync,
+  };
+});
+
+describe("cipher", () => {
+  const mockConfig = {
+    secrets: {
+      crypto_secret: "test-secret-key"
+    }
+  };
+  
+  describe("encrypt", () => {
+    test("encrypts plaintext string", () => {
+      const plaintext = "sensitive data";
+      const encrypted = cipher.encrypt(plaintext, mockConfig);
+      
+      // Check that the output has the expected format (IV:encryptedData)
+      expect(encrypted).toContain(":");
+      const [ivHex, encryptedData] = encrypted.split(":");
+      
+      // IV should be 32 hex characters (16 bytes)
+      expect(ivHex.length).toBe(32);
+      // Encrypted data should be present
+      expect(encryptedData.length).toBeGreaterThan(0);
+      
+      // Verify randomBytes was called to generate an IV
+      expect(randomBytes).toHaveBeenCalledWith(16);
+    });
+  });
+  
+  describe("decrypt", () => {
+    test("decrypts encrypted string back to original plaintext", () => {
+      const plaintext = "sensitive data to encrypt and decrypt";
+      const encrypted = cipher.encrypt(plaintext, mockConfig);
+      const decrypted = cipher.decrypt(encrypted, mockConfig);
+      
+      expect(decrypted).toBe(plaintext);
+    });
+  });
+  
+  test("encrypt and decrypt cycle works for complex data", () => {
+    const complexData = JSON.stringify({
+      id: 12345,
+      name: "Test User",
+      email: "test@example.com",
+      permissions: ["admin", "editor"],
+      metadata: {
+        lastLogin: "2024-05-15T12:30:00Z",
+        browser: "Chrome"
+      }
+    });
+    
+    const encrypted = cipher.encrypt(complexData, mockConfig);
+    const decrypted = cipher.decrypt(encrypted, mockConfig);
+    
+    expect(decrypted).toBe(complexData);
+    expect(JSON.parse(decrypted)).toEqual(JSON.parse(complexData));
+  });
+});