@raketa-cloud/admin 1.8.4 → 1.8.6

package/src/tests/handlers/{articles → resources}/URLsHandler.test/create.test.js

@@ -1,94 +1,98 @@
-import URLsHandler from "../../../../handlers/articles/URLsHandler";
-import Articles from "../../../../cloud/Articles";
+import URLsHandler from "../../../../handlers/resources/URLsHandler";
+import Resources from "../../../../cloud/Resources";
 import Factory from "../../../support/factory";
 import { remoteConfig } from "../../../support/handlersHelper";
 
-function buildCtx(article, updateSettings) {
+function buildCtx(resource, updateSettings) {
   return {
     client: {
-      articles: new Articles(() => ({}), "token"),
+      resources: new Resources(() => ({}), "token"),
     },
-    params: { parent_id: article.id },
+    params: { parent_id: resource.id },
     resourceParams: {
       resource: updateSettings,
     },
     locale: "en",
     remoteConfig: remoteConfig(),
     resourceConfig: {
-      articleType: "article",
-      articleTypePlural: "articles",
+      resourceType: "article",
+      resourceTypePlural: "articles",
     },
   };
 }
 
-describe("Article change url", () => {
+describe("Resource change url", () => {
   test("create successful", async () => {
-    const article = Factory.build("article");
+    const resource = Factory.build("resource");
     const updateSettings = {
       slug: "new-slug",
       redirect: "1",
     };
-    const ctx = buildCtx(article, updateSettings);
+    const ctx = buildCtx(resource, updateSettings);
 
     const mockFind = jest
-      .spyOn(ctx.client.articles, "find")
-      .mockImplementation(() => article);
+      .spyOn(ctx.client.resources, "find")
+      .mockImplementation(() => resource);
 
     const mockChange = jest
-      .spyOn(ctx.client.articles, "updateSlug")
-      .mockImplementation(() => ({ article, errors: null }));
+      .spyOn(ctx.client.resources, "updateSlug")
+      .mockImplementation(() => ({ resource, errors: null }));
 
     const result = await URLsHandler.create(ctx);
 
-    expect(mockFind).toHaveBeenCalledWith(article.id, "en");
+    expect(mockFind).toHaveBeenCalledWith(resource.id, "en", "article");
     expect(mockChange).toHaveBeenCalledWith(
-      article.id,
+      resource.id,
       updateSettings.slug,
       "en",
+      "article",
       {
-        url: `/en/blog/${article.slug}`,
+        url: `/en/blog/${resource.slug}`,
         destination: `/en/blog/${updateSettings.slug}`,
         httpResponseCode: 301,
-        note: "Created with changed URL for a resource of type article",
+        note: "Created with changed URL for a article",
       }
     );
 
     expect(result).toEqual({
-      redirect: `/en/articles/${article.id}`,
+      redirect: `/en/articles/${resource.id}`,
     });
   });
 
   test("create failed due to slug error", async () => {
-    const article = Factory.build("article");
+    const resource = Factory.build("resource");
     const updateSettings = {
       slug: "new-slug",
     };
-    const ctx = buildCtx(article, updateSettings);
+    const ctx = buildCtx(resource, updateSettings);
 
     const mockFind = jest
-      .spyOn(ctx.client.articles, "find")
-      .mockImplementation(() => article);
+      .spyOn(ctx.client.resources, "find")
+      .mockImplementation(() => resource);
 
     const mockChange = jest
-      .spyOn(ctx.client.articles, "updateSlug")
+      .spyOn(ctx.client.resources, "updateSlug")
       .mockImplementation(() => ({
-        article: null,
-        errors: [{ codes: [], key: "slug", message: "has already been taken" }],
+        resource: null,
+        errors: [
+          { codes: [], key: "slug", message: "has already been taken" },
+        ],
       }));
 
     const result = await URLsHandler.create(ctx);
 
-    expect(mockFind).toHaveBeenCalledWith(article.id, "en");
+    expect(mockFind).toHaveBeenCalledWith(resource.id, "en", "article");
     expect(mockChange).toHaveBeenCalledWith(
-      article.id,
+      resource.id,
       updateSettings.slug,
       "en",
+      "article",
       null
     );
 
     expect(result).toEqual({
       assigns: {
-        resource: { ...updateSettings, id: article.id },
+        resource: { ...updateSettings, id: resource.id },
         errors: { resource: { slug: "has already been taken" } },
         _translations: [],
       },
@@ -96,21 +100,21 @@ describe("Article change url", () => {
   });
 
   test("create failed due to redirect create", async () => {
-    const article = Factory.build("article");
+    const resource = Factory.build("resource");
     const updateSettings = {
       slug: "new-slug",
       redirect: "1",
     };
-    const ctx = buildCtx(article, updateSettings);
+    const ctx = buildCtx(resource, updateSettings);
 
     const mockFind = jest
-      .spyOn(ctx.client.articles, "find")
-      .mockImplementation(() => article);
+      .spyOn(ctx.client.resources, "find")
+      .mockImplementation(() => resource);
 
     const mockChange = jest
-      .spyOn(ctx.client.articles, "updateSlug")
+      .spyOn(ctx.client.resources, "updateSlug")
       .mockImplementation(() => ({
-        article: null,
+        resource: null,
         errors: [
           {
             codes: [],
@@ -122,39 +126,40 @@ describe("Article change url", () => {
 
     const result = await URLsHandler.create(ctx);
 
-    expect(mockFind).toHaveBeenCalledWith(article.id, "en");
+    expect(mockFind).toHaveBeenCalledWith(resource.id, "en", "article");
     expect(mockChange).toHaveBeenCalledWith(
-      article.id,
+      resource.id,
       updateSettings.slug,
       "en",
+      "article",
       {
-        url: `/en/blog/${article.slug}`,
+        url: `/en/blog/${resource.slug}`,
         destination: `/en/blog/${updateSettings.slug}`,
         httpResponseCode: 301,
-        note: "Created with changed URL for a resource of type article",
+        note: "Created with changed URL for a article",
       }
     );
 
     expect(result).toEqual({
       assigns: {
-        resource: { ...updateSettings, id: article.id },
+        resource: { ...updateSettings, id: resource.id },
         errors: { resource: { redirect: "url: has already been taken" } },
         _translations: [],
       },
     });
   });
 
-  test("create for non existing article", async () => {
+  test("create for non existing resource", async () => {
     const ctx = buildCtx({ id: "42" }, {});
 
     const mockFind = jest
-      .spyOn(ctx.client.articles, "find")
+      .spyOn(ctx.client.resources, "find")
       .mockImplementation(() => null);
 
     expect(async () => {
       await URLsHandler.create(ctx);
     }).rejects.toThrow("Cannot find article with id 42");
 
-    expect(mockFind).toHaveBeenCalledWith("42", "en");
+    expect(mockFind).toHaveBeenCalledWith("42", "en", "article");
   });
 });

package/src/tests/handlers/resources/URLsHandler.test/create_form.test.js

@@ -0,0 +1,55 @@
+import Resources from "../../../../cloud/Resources";
+import URLsHandler from "../../../../handlers/resources/URLsHandler";
+import Factory from "../../../support/factory";
+
+function buildCtx(resource) {
+  return {
+    client: {
+      resources: new Resources(() => ({}), "token"),
+    },
+    params: { parent_id: resource.id },
+    locale: "en",
+    resourceConfig: {
+      resourceType: "article",
+      resourceTypePlural: "articles",
+    },
+  };
+}
+
+describe("Resource change url", () => {
+  test("create_form for existing resource", async () => {
+    const resource = Factory.build("resource");
+    const ctx = buildCtx(resource);
+
+    const mockFind = jest
+      .spyOn(ctx.client.resources, "find")
+      .mockImplementation(() => resource);
+
+    const result = await URLsHandler.create_form(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(resource.id, "en", "article");
+
+    expect(result).toEqual({
+      assigns: {
+        record: resource,
+        resource: { slug: resource.slug, id: resource.id, redirect: null },
+        errors: {},
+        _translations: [],
+      },
+    });
+  });
+
+  test("create_form for non existing resource", async () => {
+    const ctx = buildCtx({ id: "42" });
+
+    const mockFind = jest
+      .spyOn(ctx.client.resources, "find")
+      .mockImplementation(() => null);
+
+    expect(async () => {
+      await URLsHandler.create_form(ctx);
+    }).rejects.toThrow("Cannot find article with id 42");
+
+    expect(mockFind).toHaveBeenCalledWith("42", "en", "article");
+  });
+});

package/src/tests/routeArticlesModule.test.js

@@ -0,0 +1,43 @@
+import routeArticlesModule from "../routeArticlesModule";
+import routeResource from "../routeResource";
+
+jest.mock("../routeResource", () => jest.fn());
+
+describe("routeArticlesModule", () => {
+  beforeEach(() => {
+    routeResource.mockClear();
+  });
+
+  test("delegates to routeResource with default types and publish_at dateField", () => {
+    const adapter = {};
+
+    routeArticlesModule(adapter);
+
+    expect(routeResource).toHaveBeenCalledWith(adapter, "article", "articles", {
+      viewsType: "article",
+      viewsTypePlural: "articles",
+      dateFields: ["publish_at"],
+    });
+  });
+
+  test("delegates to routeResource with custom types", () => {
+    const adapter = {};
+
+    routeArticlesModule(adapter, "post", "posts");
+
+    expect(routeResource).toHaveBeenCalledWith(adapter, "post", "posts", {
+      viewsType: "article",
+      viewsTypePlural: "articles",
+      dateFields: ["publish_at"],
+    });
+  });
+
+  test("returns value of routeResource", () => {
+    const adapter = {};
+    routeResource.mockReturnValueOnce("ok");
+
+    const result = routeArticlesModule(adapter);
+
+    expect(result).toBe("ok");
+  });
+});

package/src/tests/routeCategoriesModule.test.js

@@ -0,0 +1,23 @@
+import routeCategoriesModule from "../routeCategoriesModule";
+import routeCollection from "../routeCollection";
+import CategoriesHandler from "../handlers/categories";
+
+jest.mock("../routeCollection", () => jest.fn());
+
+describe("routeCategoriesModule", () => {
+  beforeEach(() => {
+    routeCollection.mockClear();
+  });
+
+  test("registers categories collection with categoryType + plural + viewsFallback", () => {
+    const adapter = {};
+
+    routeCategoriesModule(adapter, "tag", "tags");
+
+    expect(routeCollection).toHaveBeenCalledWith(adapter, "tags", CategoriesHandler, {
+      categoryType: "tag",
+      categoryTypePlural: "tags",
+      viewsFallback: "categories",
+    });
+  });
+});

package/src/tests/routeEventsModule.test.js

@@ -0,0 +1,43 @@
+import routeEventsModule from "../routeEventsModule";
+import routeResource from "../routeResource";
+
+jest.mock("../routeResource", () => jest.fn());
+
+describe("routeEventsModule", () => {
+  beforeEach(() => {
+    routeResource.mockClear();
+  });
+
+  test("delegates to routeResource with default types and event dateFields", () => {
+    const adapter = {};
+
+    routeEventsModule(adapter);
+
+    expect(routeResource).toHaveBeenCalledWith(adapter, "event", "events", {
+      viewsType: "event",
+      viewsTypePlural: "events",
+      dateFields: ["publish_at", "starts_at", "ends_at"],
+    });
+  });
+
+  test("delegates to routeResource with custom types", () => {
+    const adapter = {};
+
+    routeEventsModule(adapter, "meeting", "meetings");
+
+    expect(routeResource).toHaveBeenCalledWith(adapter, "meeting", "meetings", {
+      viewsType: "event",
+      viewsTypePlural: "events",
+      dateFields: ["publish_at", "starts_at", "ends_at"],
+    });
+  });
+
+  test("returns value of routeResource", () => {
+    const adapter = {};
+    routeResource.mockReturnValueOnce("ok");
+
+    const result = routeEventsModule(adapter);
+
+    expect(result).toBe("ok");
+  });
+});

package/src/tests/routePagesModule.test.js

@@ -0,0 +1,43 @@
+import routePagesModule from "../routePagesModule";
+import routeResource from "../routeResource";
+
+jest.mock("../routeResource", () => jest.fn());
+
+describe("routePagesModule", () => {
+  beforeEach(() => {
+    routeResource.mockClear();
+  });
+
+  test("delegates to routeResource with default types", () => {
+    const adapter = {};
+
+    routePagesModule(adapter);
+
+    expect(routeResource).toHaveBeenCalledWith(adapter, "page", "pages", {
+      viewsType: "page",
+      viewsTypePlural: "pages",
+      dateFields: [],
+    });
+  });
+
+  test("delegates to routeResource with custom types", () => {
+    const adapter = {};
+
+    routePagesModule(adapter, "landing", "landings");
+
+    expect(routeResource).toHaveBeenCalledWith(adapter, "landing", "landings", {
+      viewsType: "page",
+      viewsTypePlural: "pages",
+      dateFields: [],
+    });
+  });
+
+  test("returns value of routeResource", () => {
+    const adapter = {};
+    routeResource.mockReturnValueOnce("ok");
+
+    const result = routePagesModule(adapter);
+
+    expect(result).toBe("ok");
+  });
+});

package/src/tests/routeResource.test.js

@@ -0,0 +1,202 @@
+import routeResource from "../routeResource";
+
+function makeAdapter() {
+  return {
+    routeCollection: jest.fn(),
+    routeNestedCollection: jest.fn(),
+    routeNestedMember: jest.fn(),
+  };
+}
+
+describe("routeResource", () => {
+  test("registers exports collection with explicit mapping", () => {
+    const adapter = makeAdapter();
+
+    routeResource(adapter, "article", "articles", {
+      viewsType: "article",
+      viewsTypePlural: "articles",
+      dateFields: ["publish_at"],
+    });
+
+    const exportsCall = adapter.routeCollection.mock.calls[0];
+
+    expect(exportsCall[0]).toEqual([
+      [
+        "GET",
+        "/articles/exports",
+        "exports",
+        "articles/exports",
+        "index",
+        expect.any(Function),
+      ],
+    ]);
+    expect(exportsCall[1]).toEqual({
+      resourceType: "article",
+      resourceTypePlural: "articles",
+      dateFields: ["publish_at"],
+    });
+  });
+
+  test("propagates resourceConfig with dateFields to all helpers", () => {
+    const adapter = makeAdapter();
+
+    routeResource(adapter, "event", "events", {
+      viewsType: "event",
+      viewsTypePlural: "events",
+      dateFields: ["publish_at", "starts_at", "ends_at"],
+    });
+
+    const allCalls = [
+      ...adapter.routeCollection.mock.calls,
+      ...adapter.routeNestedCollection.mock.calls,
+      ...adapter.routeNestedMember.mock.calls,
+    ];
+
+    for (const [, resourceConfig] of allCalls) {
+      expect(resourceConfig).toMatchObject({
+        resourceType: "event",
+        resourceTypePlural: "events",
+        dateFields: ["publish_at", "starts_at", "ends_at"],
+      });
+    }
+  });
+
+  test("registers ResourcesHandler collection at base resource", () => {
+    const adapter = makeAdapter();
+
+    routeResource(adapter, "page", "pages", {
+      viewsType: "page",
+      viewsTypePlural: "pages",
+    });
+
+    const baseCollection = adapter.routeCollection.mock.calls.find(
+      ([mapping]) => mapping.some(([, path]) => path === "/pages")
+    );
+
+    expect(baseCollection).toBeDefined();
+    expect(baseCollection[1]).toMatchObject({
+      viewsFallback: "pages",
+    });
+  });
+
+  test("registers api collection for resources", () => {
+    const adapter = makeAdapter();
+
+    routeResource(adapter, "page", "pages", {
+      viewsType: "page",
+      viewsTypePlural: "pages",
+    });
+
+    const apiCollection = adapter.routeCollection.mock.calls.find(
+      ([mapping]) => mapping.some(([, path]) => path === "/api/pages")
+    );
+
+    expect(apiCollection).toBeDefined();
+  });
+
+  test("registers nested collections for revisions, translations, history, locks, unlocks, clones, urls, deletes, publishes, cancel_schedules, reverts", () => {
+    const adapter = makeAdapter();
+
+    routeResource(adapter, "article", "articles", {
+      viewsType: "article",
+      viewsTypePlural: "articles",
+    });
+
+    const nestedPaths = adapter.routeNestedCollection.mock.calls.flatMap(
+      ([mapping]) => mapping.map(([, path]) => path)
+    );
+
+    expect(nestedPaths).toEqual(
+      expect.arrayContaining([
+        "/articles/:parent_id/translations",
+        "/articles/:parent_id/history",
+        "/articles/:parent_id/article_revisions",
+        "/article_revisions/:parent_id/locks",
+        "/article_revisions/:parent_id/unlocks",
+        "/articles/:parent_id/clones",
+        "/articles/:parent_id/urls",
+        "/articles/:parent_id/deletes",
+        "/articles/:parent_id/article_changes/reverts",
+        "/article_revisions/:parent_id/publishes",
+        "/article_revisions/:parent_id/cancel_schedules",
+      ])
+    );
+  });
+
+  test("registers nested members for general, visuals, codes, meta, tags", () => {
+    const adapter = makeAdapter();
+
+    routeResource(adapter, "article", "articles", {
+      viewsType: "article",
+      viewsTypePlural: "articles",
+    });
+
+    const nestedMemberPaths = adapter.routeNestedMember.mock.calls.flatMap(
+      ([mapping]) => mapping.map(([, path]) => path)
+    );
+
+    expect(nestedMemberPaths).toEqual(
+      expect.arrayContaining([
+        "/article_revisions/:parent_id/general",
+        "/article_revisions/:parent_id/visuals",
+        "/article_revisions/:parent_id/codes",
+        "/article_revisions/:parent_id/meta",
+        "/article_revisions/:parent_id/tags",
+      ])
+    );
+  });
+
+  test("registers api widgets and change endpoints", () => {
+    const adapter = makeAdapter();
+
+    routeResource(adapter, "page", "pages", {
+      viewsType: "page",
+      viewsTypePlural: "pages",
+    });
+
+    const nestedMemberPaths = adapter.routeNestedMember.mock.calls.flatMap(
+      ([mapping]) => mapping.map(([, path]) => path)
+    );
+
+    expect(nestedMemberPaths).toEqual(
+      expect.arrayContaining([
+        "/api/page_revisions/:parent_id/widgets",
+        "/api/page/:parent_id/change",
+      ])
+    );
+  });
+
+  test("uses default empty dateFields when not provided", () => {
+    const adapter = makeAdapter();
+
+    routeResource(adapter, "page", "pages", {
+      viewsType: "page",
+      viewsTypePlural: "pages",
+    });
+
+    const firstCall = adapter.routeCollection.mock.calls[0];
+    expect(firstCall[1].dateFields).toEqual([]);
+  });
+
+  test("propagates viewsFallback with viewsTypePlural for collection helpers", () => {
+    const adapter = makeAdapter();
+
+    routeResource(adapter, "event", "events", {
+      viewsType: "event",
+      viewsTypePlural: "events",
+    });
+
+    const baseCollection = adapter.routeCollection.mock.calls.find(
+      ([mapping]) => mapping.some(([, path]) => path === "/events")
+    );
+
+    expect(baseCollection[1].viewsFallback).toBe("events");
+
+    const translationsCall = adapter.routeNestedCollection.mock.calls.find(
+      ([mapping]) =>
+        mapping.some(([, path]) => path === "/events/:parent_id/translations")
+    );
+
+    expect(translationsCall[1].viewsFallback).toBe("events/translations");
+  });
+});

package/src/tests/routeSettings.test.js

@@ -0,0 +1,40 @@
+import routeSettings from "../routeSettings";
+import routeMember from "../routeMember";
+import SettingsHandler from "../handlers/_shared/SettingsHandler";
+
+jest.mock("../routeMember", () => jest.fn());
+
+describe("routeSettings", () => {
+  beforeEach(() => {
+    routeMember.mockClear();
+  });
+
+  test("registers meta, layout, variables members", () => {
+    const adapter = {};
+
+    routeSettings(adapter);
+
+    expect(routeMember).toHaveBeenCalledTimes(3);
+    expect(routeMember).toHaveBeenNthCalledWith(
+      1,
+      adapter,
+      "settings/meta",
+      SettingsHandler,
+      { resource: "settings/meta" }
+    );
+    expect(routeMember).toHaveBeenNthCalledWith(
+      2,
+      adapter,
+      "settings/layout",
+      SettingsHandler,
+      { resource: "settings/layout" }
+    );
+    expect(routeMember).toHaveBeenNthCalledWith(
+      3,
+      adapter,
+      "settings/variables",
+      SettingsHandler,
+      { resource: "settings/variables" }
+    );
+  });
+});