@carlonicora/nextjs-jsonapi 5.3.0 → 5.4.0

package/src/features/blog/components/public/__tests__/BlogList.spec.tsx

@@ -0,0 +1,173 @@
+import { render, screen } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { configureI18n } from "../../../../../i18n";
+import type { PublicBlogCategory, PublicBlogPost } from "../../../types/blog-public.types";
+import { BlogList } from "../BlogList";
+
+// t interpolates its values after the key so assertions can see them.
+vi.mock("next-intl", () => ({
+  useTranslations: () => (key: string, values?: Record<string, unknown>) =>
+    values ? `${key} ${Object.values(values).join(" ")}` : key,
+  useFormatter: () => ({ dateTime: (date: Date) => date.toISOString().slice(0, 10) }),
+}));
+vi.mock("next/image", () => ({
+  default: ({ src, alt }: { src: string; alt: string }) => <img src={src} alt={alt} />,
+}));
+
+const cats: PublicBlogCategory[] = [
+  { id: "c1", name: "Game prep", slug: "game-prep" },
+  { id: "c2", name: "Product", slug: "product" },
+];
+
+const post = (overrides: Partial<PublicBlogPost>): PublicBlogPost => ({
+  id: "p",
+  language: "en",
+  title: "Title",
+  slug: "title",
+  summary: "Summary",
+  readingMinutes: 4,
+  publishedAt: "2026-10-12T09:00:00.000Z",
+  updatedAt: "2026-10-12T09:00:00.000Z",
+  authorName: "Carlo Nicora",
+  categoryIds: ["c1"],
+  ...overrides,
+});
+
+const p1 = post({
+  id: "p1",
+  title: "Prep situations, not plots",
+  slug: "prep-situations",
+  summary: "Why a scene that can go three ways beats a scene that must go one way.",
+  coverImage: "https://cdn.test/p1.webp",
+});
+const p2 = post({
+  id: "p2",
+  title: "Voice attribution, explained",
+  slug: "voice",
+  summary: "How it knows who spoke.",
+  categoryIds: ["c2"],
+});
+const p3 = post({
+  id: "p3",
+  title: "Clues that point, not explain",
+  slug: "clues",
+  summary: "Make every clue a pointer.",
+});
+
+beforeEach(() => {
+  configureI18n({
+    useRouter: () => ({
+      push: () => {},
+      replace: () => {},
+      back: () => {},
+      forward: () => {},
+      refresh: () => {},
+      prefetch: () => {},
+    }),
+    useTranslations: () => (key: string) => key,
+    usePathname: () => "/blog",
+    getLocale: async () => "en",
+    Link: ({ href, children, prefetch: _prefetch, scroll: _scroll, ...props }: any) => (
+      <a href={href} {...props}>
+        {children}
+      </a>
+    ),
+  });
+});
+
+describe("BlogList", () => {
+  it.each(["featured", "column", "rail"] as const)("%s layout renders every post title and a summary", (layout) => {
+    render(
+      <BlogList
+        layout={layout}
+        list={{ posts: [p1, p2, p3], hasMore: false }}
+        categories={cats}
+        page={1}
+        basePath="/blog"
+      />,
+    );
+
+    expect(screen.getAllByRole("link", { name: /Prep situations/ })[0]).toHaveAttribute(
+      "href",
+      "/blog/prep-situations",
+    );
+    expect(screen.getAllByRole("link", { name: /Voice attribution/ })[0]).toHaveAttribute("href", "/blog/voice");
+    expect(screen.getAllByRole("link", { name: /Clues that point/ })[0]).toHaveAttribute("href", "/blog/clues");
+    expect(screen.getByText(p3.summary!)).toBeInTheDocument();
+    expect(screen.getAllByText(/blog\.public\.readingTime 4/).length).toBeGreaterThanOrEqual(3);
+    // One real h1 per page (public SEO page), carried by ContentTitle; the eyebrow is not part of it.
+    expect(screen.getAllByRole("heading", { level: 1 })).toHaveLength(1);
+    expect(screen.getByRole("heading", { level: 1, name: "blog.public.title" })).toBeInTheDocument();
+    expect(screen.getByText("blog.public.eyebrow")).toBeInTheDocument();
+  });
+
+  it("active category chip is marked and links back to all", () => {
+    render(
+      <BlogList
+        layout="featured"
+        list={{ posts: [p1], hasMore: false }}
+        categories={cats}
+        activeCategorySlug="game-prep"
+        page={1}
+        basePath="/blog"
+      />,
+    );
+
+    const active = screen.getByRole("link", { name: "Game prep" });
+    expect(active).toHaveAttribute("aria-current", "page");
+    expect(active).toHaveAttribute("href", "/blog?category=game-prep");
+    expect(screen.getByRole("link", { name: "Product" })).not.toHaveAttribute("aria-current");
+    const all = screen.getByRole("link", { name: "blog.public.all" });
+    expect(all).toHaveAttribute("href", "/blog");
+    expect(all).not.toHaveAttribute("aria-current");
+  });
+
+  it("load more links to the next page keeping filters", () => {
+    render(
+      <BlogList
+        layout="column"
+        list={{ posts: [p1], hasMore: true }}
+        categories={cats}
+        activeCategorySlug="game-prep"
+        query="x"
+        page={1}
+        basePath="/blog"
+      />,
+    );
+
+    expect(screen.getByRole("link", { name: "blog.public.loadMore" })).toHaveAttribute(
+      "href",
+      "/blog?category=game-prep&q=x&page=2",
+    );
+  });
+
+  it("hides load more when there is nothing more", () => {
+    render(
+      <BlogList layout="rail" list={{ posts: [p1], hasMore: false }} categories={cats} page={1} basePath="/blog" />,
+    );
+    expect(screen.queryByRole("link", { name: "blog.public.loadMore" })).not.toBeInTheDocument();
+  });
+
+  it("empty list with a query shows noResults", () => {
+    render(
+      <BlogList
+        layout="featured"
+        list={{ posts: [], hasMore: false }}
+        categories={cats}
+        query="zzz"
+        page={1}
+        basePath="/blog"
+      />,
+    );
+    expect(screen.getByText("blog.public.noResults")).toBeInTheDocument();
+    expect(screen.queryByText("blog.public.empty")).not.toBeInTheDocument();
+  });
+
+  it("empty list without a query shows empty", () => {
+    render(
+      <BlogList layout="column" list={{ posts: [], hasMore: false }} categories={cats} page={1} basePath="/blog" />,
+    );
+    expect(screen.getByText("blog.public.empty")).toBeInTheDocument();
+  });
+});

package/src/features/blog/components/public/__tests__/BlogPostView.spec.tsx

@@ -0,0 +1,128 @@
+import { render, screen } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { configureI18n } from "../../../../../i18n";
+import type { PublicBlogCategory, PublicBlogPost } from "../../../types/blog-public.types";
+import { BlogPostView } from "../BlogPostView";
+
+// t interpolates its values after the key so assertions can see them.
+vi.mock("next-intl", () => ({
+  useTranslations: () => (key: string, values?: Record<string, unknown>) =>
+    values ? `${key} ${Object.values(values).join(" ")}` : key,
+  useFormatter: () => ({ dateTime: (date: Date) => date.toISOString().slice(0, 10) }),
+}));
+vi.mock("next/image", () => ({
+  default: ({ src, alt }: { src: string; alt: string }) => <img src={src} alt={alt} />,
+}));
+// The real editor is a next/dynamic ssr:false import; assert on the props it receives.
+vi.mock("../../../../../components/editors/BlockNoteEditorContainer", () => ({
+  BlockNoteEditorContainer: ({ id, type, initialContent }: { id: string; type: string; initialContent: unknown }) => (
+    <div data-testid="post-body" data-id={id} data-type={type}>
+      {JSON.stringify(initialContent)}
+    </div>
+  ),
+}));
+
+const cats: PublicBlogCategory[] = [{ id: "c1", name: "Game prep", slug: "game-prep" }];
+
+const post = (overrides: Partial<PublicBlogPost>): PublicBlogPost => ({
+  id: "p",
+  language: "en",
+  title: "Title",
+  slug: "title",
+  readingMinutes: 4,
+  publishedAt: "2026-10-12T09:00:00.000Z",
+  updatedAt: "2026-10-12T09:00:00.000Z",
+  categoryIds: ["c1"],
+  ...overrides,
+});
+
+const main = post({
+  id: "p1",
+  title: "Prep situations, not plots",
+  slug: "prep-situations",
+  summary: "Why a scene that can go three ways beats a scene that must go one way.",
+  body: [{ type: "paragraph", content: [{ type: "text", text: "Every GM has lived that moment" }] }],
+  coverImage: "https://cdn.test/p1.webp",
+  coverImageAlt: "A table with dice",
+  readingMinutes: 6,
+  authorName: "Carlo Nicora",
+  updatedAt: "2026-10-15T09:00:00.000Z",
+});
+const r1 = post({
+  id: "r1",
+  title: "Clues that point, not explain",
+  slug: "clues",
+  summary: "Make every clue a pointer.",
+});
+const r2 = post({ id: "r2", title: "Three-way scenes", slug: "three-way" });
+
+beforeEach(() => {
+  configureI18n({
+    useRouter: () => ({
+      push: () => {},
+      replace: () => {},
+      back: () => {},
+      forward: () => {},
+      refresh: () => {},
+      prefetch: () => {},
+    }),
+    useTranslations: () => (key: string) => key,
+    usePathname: () => "/blog/prep-situations",
+    getLocale: async () => "en",
+    Link: ({ href, children, prefetch: _prefetch, scroll: _scroll, ...props }: any) => (
+      <a href={href} {...props}>
+        {children}
+      </a>
+    ),
+  });
+});
+
+describe("BlogPostView", () => {
+  it("shows category, title, author, reading time and more-in links", () => {
+    render(<BlogPostView post={main} categories={cats} related={[r1, r2]} basePath="/blog" />);
+
+    expect(screen.getByRole("link", { name: /blog\.public\.back/ })).toHaveAttribute("href", "/blog");
+    expect(screen.getAllByText("Game prep")[0]).toBeInTheDocument();
+    expect(screen.getAllByRole("heading", { level: 1 })).toHaveLength(1);
+    expect(screen.getByRole("heading", { level: 1, name: "Prep situations, not plots" })).toBeInTheDocument();
+    expect(screen.getByText(main.summary!)).toBeInTheDocument();
+    expect(screen.getByText("blog.public.by Carlo Nicora")).toBeInTheDocument();
+    expect(screen.getByText(/blog\.public\.readingTime 6/)).toBeInTheDocument();
+    expect(screen.getByAltText("A table with dice")).toHaveAttribute("src", "https://cdn.test/p1.webp");
+    const body = screen.getByTestId("post-body");
+    expect(body).toHaveTextContent("Every GM has lived that moment");
+    expect(body).toHaveAttribute("data-id", "p1");
+    expect(body).toHaveAttribute("data-type", "blog-post");
+
+    expect(screen.getByRole("heading", { level: 2, name: "blog.public.moreIn Game prep" })).toBeInTheDocument();
+    expect(screen.getByRole("link", { name: "Clues that point, not explain" })).toHaveAttribute("href", "/blog/clues");
+    expect(screen.getByRole("link", { name: "Three-way scenes" })).toHaveAttribute("href", "/blog/three-way");
+  });
+
+  it("shows updated only when the post changed more than a day after publishing", () => {
+    const { rerender } = render(<BlogPostView post={main} categories={cats} related={[]} basePath="/blog" />);
+    expect(screen.getByText(/blog\.public\.updated 2026-10-15/)).toBeInTheDocument();
+
+    rerender(
+      <BlogPostView
+        post={{ ...main, updatedAt: "2026-10-12T15:00:00.000Z" }}
+        categories={cats}
+        related={[]}
+        basePath="/blog"
+      />,
+    );
+    expect(screen.queryByText(/blog\.public\.updated/)).not.toBeInTheDocument();
+  });
+
+  it("omits the more-in section when there are no related posts", () => {
+    render(<BlogPostView post={main} categories={cats} related={[]} basePath="/blog" />);
+    expect(screen.queryByText(/blog\.public\.moreIn/)).not.toBeInTheDocument();
+  });
+
+  it("caps related posts at three", () => {
+    const many = [1, 2, 3, 4].map((n) => post({ id: `r${n}`, title: `Related ${n}`, slug: `related-${n}` }));
+    render(<BlogPostView post={main} categories={cats} related={many} basePath="/blog" />);
+    expect(screen.getAllByRole("heading", { level: 3 })).toHaveLength(3);
+  });
+});

package/src/features/blog/components/public/blogPublicHelpers.ts

@@ -0,0 +1,30 @@
+import type { PublicBlogCategory, PublicBlogPost } from "../../types/blog-public.types";
+
+/**
+ * Locale-free href to the public list, keeping the active filters.
+ * Parameter order is fixed (category, q, page) so links are stable.
+ */
+export function blogListHref(basePath: string, params: { category?: string; q?: string; page?: number }): string {
+  const search = new URLSearchParams();
+  if (params.category) search.set("category", params.category);
+  if (params.q) search.set("q", params.q);
+  if (params.page && params.page > 1) search.set("page", String(params.page));
+  const query = search.toString();
+  return query ? `${basePath}?${query}` : basePath;
+}
+
+export function blogPostHref(basePath: string, slug: string): string {
+  return `${basePath}/${encodeURIComponent(slug)}`;
+}
+
+/** The first of the post's categories that the visitor's category list knows. */
+export function resolvePostCategory(
+  post: PublicBlogPost,
+  categories: PublicBlogCategory[],
+): PublicBlogCategory | undefined {
+  for (const id of post.categoryIds) {
+    const category = categories.find((c) => c.id === id);
+    if (category) return category;
+  }
+  return undefined;
+}

package/src/features/blog/components/public/index.ts

@@ -0,0 +1,3 @@
+export { BlogList } from "./BlogList";
+export type { BlogListProps } from "./BlogList";
+export { BlogPostView } from "./BlogPostView";

package/src/features/blog/contexts/BlogPostContext.tsx

@@ -0,0 +1,66 @@
+"use client";
+
+import { createContext, ReactNode, useCallback, useContext, useEffect, useMemo, useState } from "react";
+import { BlogPostInterface, BlogPostService } from "../data";
+
+/** How often the post page re-reads the post while a translation job runs. */
+const TRANSLATION_POLL_MS = 5000;
+
+export interface BlogPostContextType {
+  post: BlogPostInterface | undefined;
+  reload: () => Promise<void>;
+}
+
+const BlogPostContext = createContext<BlogPostContextType | undefined>(undefined);
+
+export type BlogPostProviderProps = {
+  postId: string;
+  children: ReactNode;
+};
+
+/**
+ * Loads one post (with its translations, categories and author) for the admin
+ * post page. While any translation is `pending` or `in_progress` it re-reads
+ * the post every 5 s, so the language tabs move from "Translating…" to the
+ * translated text without a manual refresh; it stops once none are running.
+ */
+export const BlogPostProvider = ({ postId, children }: BlogPostProviderProps) => {
+  const [post, setPost] = useState<BlogPostInterface | undefined>(undefined);
+
+  const reload = useCallback(async () => {
+    const loaded = await BlogPostService.findOne({ id: postId });
+    setPost(loaded);
+  }, [postId]);
+
+  useEffect(() => {
+    void reload();
+  }, [reload]);
+
+  const isTranslating = useMemo(
+    () =>
+      (post?.translations ?? []).some(
+        (translation) => translation.aiStatus === "pending" || translation.aiStatus === "in_progress",
+      ),
+    [post],
+  );
+
+  useEffect(() => {
+    if (!isTranslating) return;
+    const handle = setInterval(() => {
+      reload().catch(() => {});
+    }, TRANSLATION_POLL_MS);
+    return () => clearInterval(handle);
+  }, [isTranslating, reload]);
+
+  const value = useMemo<BlogPostContextType>(() => ({ post, reload }), [post, reload]);
+
+  return <BlogPostContext.Provider value={value}>{children}</BlogPostContext.Provider>;
+};
+
+export const useBlogPost = (): BlogPostContextType => {
+  const context = useContext(BlogPostContext);
+  if (context === undefined) {
+    throw new Error("useBlogPost must be used within a BlogPostProvider");
+  }
+  return context;
+};

package/src/features/blog/contexts/index.ts

@@ -0,0 +1 @@
+export * from "./BlogPostContext";

package/src/features/blog/data/BlogCategory.ts

@@ -0,0 +1,93 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { BlogCategoryInput, BlogCategoryInterface } from "./BlogCategoryInterface";
+import { BlogCategoryTranslationInterface } from "./BlogCategoryTranslationInterface";
+
+export class BlogCategory extends AbstractApiData implements BlogCategoryInterface {
+  private _originalLanguage?: string;
+  private _image?: string;
+  private _translations?: BlogCategoryTranslationInterface[];
+
+  private _language?: string;
+  private _name?: string;
+  private _slug?: string;
+  private _description?: string;
+
+  get originalLanguage(): string {
+    return this._originalLanguage ?? "";
+  }
+
+  get image(): string | undefined {
+    return this._image;
+  }
+
+  get translations(): BlogCategoryTranslationInterface[] {
+    return this._translations ?? [];
+  }
+
+  get original(): BlogCategoryTranslationInterface | undefined {
+    return this.translations.find((translation) => translation.isOriginal);
+  }
+
+  get language(): string | undefined {
+    return this._language;
+  }
+
+  get name(): string | undefined {
+    return this._name;
+  }
+
+  get slug(): string | undefined {
+    return this._slug;
+  }
+
+  get description(): string | undefined {
+    return this._description;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    const attributes = data.jsonApi.attributes ?? {};
+    const meta = data.jsonApi.meta ?? {};
+    // The resolved-language values are computed on the API. Depending on the
+    // descriptor they arrive as attributes or as meta, so both are read.
+    const resolved = (key: string) => attributes[key] ?? meta[key] ?? undefined;
+
+    this._originalLanguage = attributes.originalLanguage;
+    this._image = attributes.image ?? undefined;
+
+    this._language = resolved("language");
+    this._name = resolved("name");
+    this._slug = resolved("slug");
+    this._description = resolved("description");
+
+    this._translations = this._readIncluded(
+      data,
+      "translations",
+      Modules.BlogCategoryTranslation,
+    ) as BlogCategoryTranslationInterface[];
+
+    return this;
+  }
+
+  createJsonApi(data: BlogCategoryInput) {
+    const response: any = {
+      data: {
+        type: Modules.BlogCategory.name,
+        id: data.id,
+        attributes: {},
+        meta: {},
+        relationships: {},
+      },
+      included: [],
+    };
+
+    if (data.originalLanguage !== undefined) response.data.attributes.originalLanguage = data.originalLanguage;
+    if (data.name !== undefined) response.data.attributes.name = data.name;
+    if (data.slug !== undefined) response.data.attributes.slug = data.slug;
+    if (data.description !== undefined) response.data.attributes.description = data.description;
+    if (data.image !== undefined) response.data.attributes.image = data.image;
+
+    return response;
+  }
+}

package/src/features/blog/data/BlogCategoryFields.ts

@@ -0,0 +1,4 @@
+export enum BlogCategoryFields {
+  name = "name",
+  languages = "languages",
+}

package/src/features/blog/data/BlogCategoryInterface.ts

@@ -0,0 +1,24 @@
+import { ApiDataInterface } from "../../../core";
+import { BlogCategoryTranslationInterface } from "./BlogCategoryTranslationInterface";
+
+export type BlogCategoryInput = {
+  id: string;
+  originalLanguage?: string;
+  name?: string;
+  slug?: string;
+  description?: string;
+  image?: string;
+};
+
+export interface BlogCategoryInterface extends ApiDataInterface {
+  get originalLanguage(): string;
+  get image(): string | undefined;
+  get translations(): BlogCategoryTranslationInterface[];
+  get original(): BlogCategoryTranslationInterface | undefined;
+
+  // Resolved for one language by the public and list queries.
+  get language(): string | undefined;
+  get name(): string | undefined;
+  get slug(): string | undefined;
+  get description(): string | undefined;
+}

package/src/features/blog/data/BlogCategoryService.ts

@@ -0,0 +1,54 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules, NextRef } from "../../../core";
+import { BlogCategoryInput, BlogCategoryInterface } from "./BlogCategoryInterface";
+
+export class BlogCategoryService extends AbstractService {
+  static async findMany(
+    params: { search?: string; fetchAll?: boolean; next?: NextRef } = {},
+  ): Promise<BlogCategoryInterface[]> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.BlogCategory });
+
+    if (params.fetchAll) endpoint.addAdditionalParam("fetchAll", "true");
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+
+    return this.callApi<BlogCategoryInterface[]>({
+      type: Modules.BlogCategory,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async findOne(params: { id: string }): Promise<BlogCategoryInterface> {
+    return this.callApi<BlogCategoryInterface>({
+      type: Modules.BlogCategory,
+      method: HttpMethod.GET,
+      endpoint: new EndpointCreator({ endpoint: Modules.BlogCategory, id: params.id }).generate(),
+    });
+  }
+
+  static async create(params: BlogCategoryInput): Promise<BlogCategoryInterface> {
+    return this.callApi<BlogCategoryInterface>({
+      type: Modules.BlogCategory,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({ endpoint: Modules.BlogCategory }).generate(),
+      input: params,
+    });
+  }
+
+  static async update(params: BlogCategoryInput): Promise<BlogCategoryInterface> {
+    return this.callApi<BlogCategoryInterface>({
+      type: Modules.BlogCategory,
+      method: HttpMethod.PUT,
+      endpoint: new EndpointCreator({ endpoint: Modules.BlogCategory, id: params.id }).generate(),
+      input: params,
+    });
+  }
+
+  static async delete(params: { id: string }): Promise<void> {
+    await this.callApi({
+      type: Modules.BlogCategory,
+      method: HttpMethod.DELETE,
+      endpoint: new EndpointCreator({ endpoint: Modules.BlogCategory, id: params.id }).generate(),
+    });
+  }
+}

package/src/features/blog/data/BlogCategoryTranslation.ts

@@ -0,0 +1,90 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { BlogAiStatus, BlogTranslationSource } from "../types/blog.constants";
+import { BlogCategoryInterface } from "./BlogCategoryInterface";
+import { BlogCategoryTranslationInput, BlogCategoryTranslationInterface } from "./BlogCategoryTranslationInterface";
+
+export class BlogCategoryTranslation extends AbstractApiData implements BlogCategoryTranslationInterface {
+  private _language?: string;
+  private _isOriginal?: boolean;
+  private _source?: BlogTranslationSource;
+  private _aiStatus?: BlogAiStatus;
+  private _name?: string;
+  private _slug?: string;
+  private _description?: string;
+  private _translatedAt?: Date;
+  private _category?: BlogCategoryInterface;
+
+  get language(): string {
+    return this._language ?? "";
+  }
+
+  get isOriginal(): boolean {
+    return this._isOriginal ?? false;
+  }
+
+  get source(): BlogTranslationSource {
+    return this._source ?? "ai";
+  }
+
+  get aiStatus(): BlogAiStatus {
+    return this._aiStatus ?? "pending";
+  }
+
+  get name(): string {
+    return this._name ?? "";
+  }
+
+  get slug(): string {
+    return this._slug ?? "";
+  }
+
+  get description(): string | undefined {
+    return this._description;
+  }
+
+  get translatedAt(): Date | undefined {
+    return this._translatedAt;
+  }
+
+  get category(): BlogCategoryInterface | undefined {
+    return this._category;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    const attributes = data.jsonApi.attributes ?? {};
+
+    this._language = attributes.language;
+    this._isOriginal = attributes.isOriginal === true;
+    this._source = attributes.source;
+    this._aiStatus = attributes.aiStatus;
+    this._name = attributes.name ?? undefined;
+    this._slug = attributes.slug ?? undefined;
+    this._description = attributes.description ?? undefined;
+    this._translatedAt = attributes.translatedAt ? new Date(attributes.translatedAt) : undefined;
+
+    this._category = this._readIncluded(data, "category", Modules.BlogCategory) as BlogCategoryInterface;
+
+    return this;
+  }
+
+  createJsonApi(data: BlogCategoryTranslationInput) {
+    const response: any = {
+      data: {
+        type: Modules.BlogCategoryTranslation.name,
+        id: data.id,
+        attributes: {},
+        meta: {},
+        relationships: {},
+      },
+      included: [],
+    };
+
+    if (data.name !== undefined) response.data.attributes.name = data.name;
+    if (data.slug !== undefined) response.data.attributes.slug = data.slug;
+    if (data.description !== undefined) response.data.attributes.description = data.description;
+
+    return response;
+  }
+}