@carlonicora/nextjs-jsonapi 6.32.1 → 6.33.0

package/src/components/tables/index.ts

@@ -1,3 +1,5 @@
 export * from "./cells";
 export * from "./ContentListTable";
 export * from "./ContentTableSearch";
+export * from "./SortableHeader";
+export * from "./sorting";

package/src/components/tables/sorting.ts

@@ -0,0 +1,41 @@
+/** Direction of a column sort. */
+export type SortDirection = "asc" | "desc";
+
+/**
+ * The fields a column sorts by: its `meta.sortFields` when declared (a column
+ * built from several stored fields, or whose stored property differs from its
+ * id), otherwise its id.
+ */
+export function sortFieldsOf(column: { id?: string; columnDef: { meta?: unknown } }): string[] {
+  const meta = column.columnDef.meta as { sortFields?: unknown } | undefined;
+  if (Array.isArray(meta?.sortFields) && meta.sortFields.length > 0) {
+    return meta.sortFields.filter((field): field is string => typeof field === "string");
+  }
+  return column.id ? [column.id] : [];
+}
+
+/**
+ * The direction `sort` (JSON:API wire format) gives a column sorting by `fields`,
+ * or `undefined` when `sort` is about another column or absent.
+ */
+export function sortStateFor(sort: string | undefined, fields: string[]): SortDirection | undefined {
+  if (!sort || fields.length === 0) return undefined;
+  if (sort === fields.join(",")) return "asc";
+  if (sort === fields.map((field) => `-${field}`).join(",")) return "desc";
+  return undefined;
+}
+
+/**
+ * The sort a header click sets: none → ascending → descending → none.
+ * Returns `null` to clear the sort.
+ */
+export function nextSortValue(current: string | undefined, fields: string[]): string | null {
+  switch (sortStateFor(current, fields)) {
+    case undefined:
+      return fields.join(",");
+    case "asc":
+      return fields.map((field) => `-${field}`).join(",");
+    case "desc":
+      return null;
+  }
+}

package/src/features/billing/stripe-coupon/components/lists/CouponCodesList.tsx

@@ -25,6 +25,8 @@ export function CouponCodesList({ couponId }: CouponCodesListProps) {
     retriever: (params) => StripeCouponCodeService.listByCoupon({ ...params, couponId }),
     retrieverParams: {},
     module: Modules.StripeCouponCode,
+    // Display only (call C8): the server's own order when no sort is chosen.
+    defaultSort: "createdAt",
   });
 
   // Switching "Apply automatically" on one code clears it on the others in the

package/src/features/billing/stripe-coupon/components/lists/CouponsList.tsx

@@ -31,6 +31,8 @@ export function CouponsList({ fullWidth }: CouponsListProps = {}) {
     retriever: (params) => StripeCouponService.listCoupons(params),
     retrieverParams: {},
     module: Modules.StripeCoupon,
+    // Display only (call C8): the server's own order when no sort is chosen.
+    defaultSort: "-updatedAt",
   });
 
   // Renames and code changes happen on the detail page, so the list has to

package/src/features/billing/stripe-coupon/data/stripe-coupon-code.service.ts

@@ -18,6 +18,8 @@ export class StripeCouponCodeService extends AbstractService {
     couponId: string;
     next?: NextRef;
     prev?: PreviousRef;
+    /** JSON:API `sort` (`name`, `-name`), forwarded to the API. */
+    sort?: string;
   }): Promise<StripeCouponCodeInterface[]> {
     const endpoint = new EndpointCreator({
       endpoint: Modules.StripeCoupon,
@@ -25,6 +27,8 @@ export class StripeCouponCodeService extends AbstractService {
       childEndpoint: Modules.StripeCouponCode,
     });
 
+    if (params.sort) endpoint.addAdditionalParam("sort", params.sort);
+
     return this.callApi({
       type: Modules.StripeCouponCode,
       method: HttpMethod.GET,

package/src/features/billing/stripe-coupon/data/stripe-coupon.service.ts

@@ -10,11 +10,17 @@ export class StripeCouponService extends AbstractService {
   /**
    * List all coupons with their codes (admin)
    */
-  static async listCoupons(params?: { next?: NextRef; prev?: PreviousRef }): Promise<StripeCouponInterface[]> {
+  static async listCoupons(params?: {
+    next?: NextRef;
+    prev?: PreviousRef;
+    sort?: string;
+  }): Promise<StripeCouponInterface[]> {
     const endpoint = new EndpointCreator({
       endpoint: Modules.StripeCoupon,
     });
 
+    if (params?.sort) endpoint.addAdditionalParam("sort", params?.sort);
+
     return this.callApi({
       type: Modules.StripeCoupon,
       method: HttpMethod.GET,

package/src/features/billing/stripe-coupon/hooks/__tests__/useStripeCouponCodeTableStructure.sort.spec.tsx

@@ -0,0 +1,30 @@
+import { renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { StripeCouponCodeFields } from "../../data/stripe-coupon-code.fields";
+import { useStripeCouponCodeTableStructure } from "../useStripeCouponCodeTableStructure";
+
+vi.mock("next-intl", () => ({ useTranslations: () => (key: string) => key, useLocale: () => "en" }));
+vi.mock("../../../contexts/CouponContext", () => ({ useCouponContext: () => ({}) }));
+
+/** Spec row A21: code, expiresAt, automatic, places (timesRedeemed); status is derived. Only an explicit `enableSorting: true` opts a column in (call C3). */
+describe("useStripeCouponCodeTableStructure sorting", () => {
+  it("opts in exactly the row's sortable columns", () => {
+    const { result } = renderHook(() =>
+      useStripeCouponCodeTableStructure({ data: [], fields: Object.values(StripeCouponCodeFields) as any }),
+    );
+    const columns = result.current.columns as any[];
+    const sortable = columns.filter((column) => column.enableSorting === true).map((column) => column.id);
+    expect(sortable.sort()).toEqual(["automatic", "code", "expiresAt", "places"]);
+  });
+
+  it("maps the columns whose key differs from the stored property (call C4)", () => {
+    const { result } = renderHook(() =>
+      useStripeCouponCodeTableStructure({ data: [], fields: Object.values(StripeCouponCodeFields) as any }),
+    );
+    const columns = result.current.columns as any[];
+    const sortFields = Object.fromEntries(
+      columns.filter((column) => column.meta?.sortFields).map((column) => [column.id, column.meta.sortFields]),
+    );
+    expect(sortFields).toEqual({ places: ["timesRedeemed"] });
+  });
+});

package/src/features/billing/stripe-coupon/hooks/__tests__/useStripeCouponTableStructure.sort.spec.tsx

@@ -0,0 +1,33 @@
+import { renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { StripeCouponFields } from "../../data/stripe-coupon.fields";
+import { useStripeCouponTableStructure } from "../useStripeCouponTableStructure";
+
+vi.mock("next-intl", () => ({ useTranslations: () => (key: string) => key, useLocale: () => "en" }));
+
+/** Spec row A20: name, status (valid), places, discount; codes (a count) is not sortable. Only an explicit `enableSorting: true` opts a column in (call C3). */
+describe("useStripeCouponTableStructure sorting", () => {
+  it("opts in exactly the row's sortable columns", () => {
+    const { result } = renderHook(() =>
+      useStripeCouponTableStructure({ data: [], fields: Object.values(StripeCouponFields) as any }),
+    );
+    const columns = result.current.columns as any[];
+    const sortable = columns.filter((column) => column.enableSorting === true).map((column) => column.id);
+    expect(sortable.sort()).toEqual(["discount", "name", "places", "status"]);
+  });
+
+  it("maps the columns whose key differs from the stored property (call C4)", () => {
+    const { result } = renderHook(() =>
+      useStripeCouponTableStructure({ data: [], fields: Object.values(StripeCouponFields) as any }),
+    );
+    const columns = result.current.columns as any[];
+    const sortFields = Object.fromEntries(
+      columns.filter((column) => column.meta?.sortFields).map((column) => [column.id, column.meta.sortFields]),
+    );
+    expect(sortFields).toEqual({
+      discount: ["discountType", "percentOff", "amountOff"],
+      places: ["timesRedeemed", "maxRedemptions"],
+      status: ["valid"],
+    });
+  });
+});

package/src/features/billing/stripe-coupon/hooks/useStripeCouponCodeTableStructure.tsx

@@ -70,7 +70,7 @@ export const useStripeCouponCodeTableStructure: UseTableStructureHook<
         const code: StripeCouponCodeInterface = row.original.jsonApiData;
         return <span className="text-xs">{code.code}</span>;
       },
-      enableSorting: false,
+      enableSorting: true,
       enableHiding: false,
     }),
     [StripeCouponCodeFields.places]: () => ({
@@ -91,7 +91,8 @@ export const useStripeCouponCodeTableStructure: UseTableStructureHook<
           </span>
         );
       },
-      enableSorting: false,
+      meta: { sortFields: ["timesRedeemed"] },
+      enableSorting: true,
       enableHiding: false,
     }),
     [StripeCouponCodeFields.expiresAt]: () => ({
@@ -106,7 +107,7 @@ export const useStripeCouponCodeTableStructure: UseTableStructureHook<
           </span>
         );
       },
-      enableSorting: false,
+      enableSorting: true,
       enableHiding: false,
     }),
     [StripeCouponCodeFields.automatic]: () => ({
@@ -121,7 +122,7 @@ export const useStripeCouponCodeTableStructure: UseTableStructureHook<
           <span className="text-muted-foreground text-xs">—</span>
         );
       },
-      enableSorting: false,
+      enableSorting: true,
       enableHiding: false,
     }),
     [StripeCouponCodeFields.status]: () => ({

package/src/features/billing/stripe-coupon/hooks/useStripeCouponTableStructure.tsx

@@ -37,7 +37,7 @@ export const useStripeCouponTableStructure: UseTableStructureHook<StripeCouponIn
         const coupon: StripeCouponInterface = row.original.jsonApiData;
         return <Link href={generateUrl({ page: STRIPE_COUPON_DETAIL_PAGE_URL, id: coupon.id })}>{coupon.name}</Link>;
       },
-      enableSorting: false,
+      enableSorting: true,
       enableHiding: false,
     }),
     [StripeCouponFields.discount]: () => ({
@@ -48,7 +48,8 @@ export const useStripeCouponTableStructure: UseTableStructureHook<StripeCouponIn
         const coupon: StripeCouponInterface = row.original.jsonApiData;
         return <span className="text-xs">{formatCouponDiscount(coupon, t, fmt)}</span>;
       },
-      enableSorting: false,
+      meta: { sortFields: ["discountType", "percentOff", "amountOff"] },
+      enableSorting: true,
       enableHiding: false,
     }),
     [StripeCouponFields.places]: () => ({
@@ -70,7 +71,8 @@ export const useStripeCouponTableStructure: UseTableStructureHook<StripeCouponIn
           </span>
         );
       },
-      enableSorting: false,
+      meta: { sortFields: ["timesRedeemed", "maxRedemptions"] },
+      enableSorting: true,
       enableHiding: false,
     }),
     [StripeCouponFields.codes]: () => ({
@@ -96,7 +98,8 @@ export const useStripeCouponTableStructure: UseTableStructureHook<StripeCouponIn
           <Badge variant="softGray">{t("billing.admin.coupons.status.ended")}</Badge>
         );
       },
-      enableSorting: false,
+      meta: { sortFields: ["valid"] },
+      enableSorting: true,
       enableHiding: false,
     }),
   };

package/src/features/billing/stripe-price/components/lists/PricesList.tsx

@@ -50,6 +50,8 @@ export function PricesList({ productId, fullWidth }: PricesListProps) {
     retriever: (params) => StripePriceService.listPrices({ ...params, productId }),
     retrieverParams: {},
     module: Modules.StripePrice,
+    // Display only (call C8): the server's own order when no sort is chosen.
+    defaultSort: "-createdAt",
   });
 
   useEffect(() => {

package/src/features/billing/stripe-price/data/stripe-price.service.ts

@@ -13,6 +13,8 @@ export class StripePriceService extends AbstractService {
     active?: boolean;
     next?: NextRef;
     prev?: PreviousRef;
+    /** JSON:API `sort` (`name`, `-name`), forwarded to the API. */
+    sort?: string;
   }): Promise<StripePriceInterface[]> {
     const endpoint = new EndpointCreator({
       endpoint: Modules.StripePrice,
@@ -25,6 +27,8 @@ export class StripePriceService extends AbstractService {
       endpoint.addAdditionalParam("active", params.active.toString());
     }
 
+    if (params?.sort) endpoint.addAdditionalParam("sort", params?.sort);
+
     return this.callApi({
       type: Modules.StripePrice,
       method: HttpMethod.GET,

package/src/features/billing/stripe-price/hooks/__tests__/useStripePriceTableStructure.sort.spec.tsx

@@ -0,0 +1,29 @@
+import { renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { StripePriceFields } from "../../data/stripe-price.fields";
+import { useStripePriceTableStructure } from "../useStripePriceTableStructure";
+
+vi.mock("next-intl", () => ({ useTranslations: () => (key: string) => key, useLocale: () => "en" }));
+
+/** Spec row A22: nickname, amount, interval, token, status. Only an explicit `enableSorting: true` opts a column in (call C3). */
+describe("useStripePriceTableStructure sorting", () => {
+  it("opts in exactly the row's sortable columns", () => {
+    const { result } = renderHook(() =>
+      useStripePriceTableStructure({ data: [], fields: Object.values(StripePriceFields) as any }),
+    );
+    const columns = result.current.columns as any[];
+    const sortable = columns.filter((column) => column.enableSorting === true).map((column) => column.id);
+    expect(sortable.sort()).toEqual(["amount", "interval", "nickname", "status", "token"]);
+  });
+
+  it("maps the columns whose key differs from the stored property (call C4)", () => {
+    const { result } = renderHook(() =>
+      useStripePriceTableStructure({ data: [], fields: Object.values(StripePriceFields) as any }),
+    );
+    const columns = result.current.columns as any[];
+    const sortFields = Object.fromEntries(
+      columns.filter((column) => column.meta?.sortFields).map((column) => [column.id, column.meta.sortFields]),
+    );
+    expect(sortFields).toEqual({ amount: ["unitAmount"], interval: ["recurringInterval"], status: ["active"] });
+  });
+});

package/src/features/billing/stripe-price/hooks/useStripePriceTableStructure.tsx

@@ -61,7 +61,7 @@ export const useStripePriceTableStructure: UseTableStructureHook<StripePriceInte
           </Link>
         );
       },
-      enableSorting: false,
+      enableSorting: true,
       enableHiding: false,
     }),
     [StripePriceFields.amount]: () => ({
@@ -77,7 +77,8 @@ export const useStripePriceTableStructure: UseTableStructureHook<StripePriceInte
           </span>
         );
       },
-      enableSorting: false,
+      meta: { sortFields: ["unitAmount"] },
+      enableSorting: true,
       enableHiding: false,
     }),
     [StripePriceFields.interval]: () => ({
@@ -89,7 +90,8 @@ export const useStripePriceTableStructure: UseTableStructureHook<StripePriceInte
         // Typography role 8 (UI chrome): single-line, plain text-xs.
         return <span className="text-xs">{formatInterval(price, fmt)}</span>;
       },
-      enableSorting: false,
+      meta: { sortFields: ["recurringInterval"] },
+      enableSorting: true,
       enableHiding: false,
     }),
     [StripePriceFields.token]: () => ({
@@ -100,7 +102,7 @@ export const useStripePriceTableStructure: UseTableStructureHook<StripePriceInte
         const price: StripePriceInterface = row.original.jsonApiData;
         return <span className="block text-xs tabular-nums text-end">{price.token ?? ""}</span>;
       },
-      enableSorting: false,
+      enableSorting: true,
       enableHiding: false,
     }),
     [StripePriceFields.status]: () => ({
@@ -123,7 +125,8 @@ export const useStripePriceTableStructure: UseTableStructureHook<StripePriceInte
           </span>
         );
       },
-      enableSorting: false,
+      meta: { sortFields: ["active"] },
+      enableSorting: true,
       enableHiding: false,
     }),
     [StripePriceFields.actions]: () => ({

package/src/features/billing/stripe-product/components/lists/ProductsList.tsx

@@ -31,6 +31,8 @@ export function ProductsList({ fullWidth }: ProductsListProps = {}) {
     retriever: (params) => StripeProductService.listProducts(params),
     retrieverParams: {},
     module: Modules.StripeProduct,
+    // Display only (call C8): the server's own order when no sort is chosen.
+    defaultSort: "name",
   });
 
   // Archiving and restoring happen on the detail page, so the list has to learn

package/src/features/billing/stripe-product/data/stripe-product.service.ts

@@ -9,6 +9,8 @@ export class StripeProductService extends AbstractService {
     active?: boolean;
     next?: NextRef;
     prev?: PreviousRef;
+    /** JSON:API `sort` (`name`, `-name`), forwarded to the API. */
+    sort?: string;
   }): Promise<StripeProductInterface[]> {
     const endpoint = new EndpointCreator({
       endpoint: Modules.StripeProduct,
@@ -18,6 +20,8 @@ export class StripeProductService extends AbstractService {
       endpoint.addAdditionalParam("active", params.active.toString());
     }
 
+    if (params?.sort) endpoint.addAdditionalParam("sort", params?.sort);
+
     return this.callApi({
       type: Modules.StripeProduct,
       method: HttpMethod.GET,

package/src/features/billing/stripe-product/hooks/__tests__/useStripeProductTableStructure.sort.spec.tsx

@@ -0,0 +1,29 @@
+import { renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { StripeProductFields } from "../../data/stripe-product.fields";
+import { useStripeProductTableStructure } from "../useStripeProductTableStructure";
+
+vi.mock("next-intl", () => ({ useTranslations: () => (key: string) => key, useLocale: () => "en" }));
+
+/** Spec row A23: name, status (active); prices (a count) is not sortable. Only an explicit `enableSorting: true` opts a column in (call C3). */
+describe("useStripeProductTableStructure sorting", () => {
+  it("opts in exactly the row's sortable columns", () => {
+    const { result } = renderHook(() =>
+      useStripeProductTableStructure({ data: [], fields: Object.values(StripeProductFields) as any }),
+    );
+    const columns = result.current.columns as any[];
+    const sortable = columns.filter((column) => column.enableSorting === true).map((column) => column.id);
+    expect(sortable.sort()).toEqual(["name", "status"]);
+  });
+
+  it("maps the columns whose key differs from the stored property (call C4)", () => {
+    const { result } = renderHook(() =>
+      useStripeProductTableStructure({ data: [], fields: Object.values(StripeProductFields) as any }),
+    );
+    const columns = result.current.columns as any[];
+    const sortFields = Object.fromEntries(
+      columns.filter((column) => column.meta?.sortFields).map((column) => [column.id, column.meta.sortFields]),
+    );
+    expect(sortFields).toEqual({ status: ["active"] });
+  });
+});

package/src/features/billing/stripe-product/hooks/useStripeProductTableStructure.tsx

@@ -35,7 +35,7 @@ export const useStripeProductTableStructure: UseTableStructureHook<StripeProduct
         const product: StripeProductInterface = row.original.jsonApiData;
         return <Link href={generateUrl({ page: Modules.StripeProduct, id: product.id })}>{product.name}</Link>;
       },
-      enableSorting: false,
+      enableSorting: true,
       enableHiding: false,
     }),
     [StripeProductFields.status]: () => ({
@@ -50,7 +50,8 @@ export const useStripeProductTableStructure: UseTableStructureHook<StripeProduct
           <Badge variant="softGray">{t("billing.admin.products.status.archived")}</Badge>
         );
       },
-      enableSorting: false,
+      meta: { sortFields: ["active"] },
+      enableSorting: true,
       enableHiding: false,
     }),
     [StripeProductFields.prices]: () => ({

package/src/features/blog/components/admin/BlogPostsList.tsx

@@ -24,6 +24,8 @@ export function BlogPostsList({ fullWidth }: BlogPostsListProps = {}) {
     retriever: (params) => BlogPostService.findMany(params),
     retrieverParams: {},
     module: Modules.BlogPost,
+    // Display only (call C8): the server's own order when no sort is chosen.
+    defaultSort: "-updatedAt",
   });
 
   // Creating navigates to the new post's page (EditorSheet's default without onSuccess).

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

@@ -3,11 +3,13 @@ import { BLOG_ACTION } from "../types/blog.constants";
 import { BlogPostInput, BlogPostInterface } from "./BlogPostInterface";
 
 export class BlogPostService extends AbstractService {
-  static async findMany(params: { search?: string; next?: NextRef } = {}): Promise<BlogPostInterface[]> {
+  static async findMany(params: { search?: string; next?: NextRef; sort?: string } = {}): Promise<BlogPostInterface[]> {
     const endpoint = new EndpointCreator({ endpoint: Modules.BlogPost });
 
     if (params.search) endpoint.addAdditionalParam("search", params.search);
 
+    if (params.sort) endpoint.addAdditionalParam("sort", params.sort);
+
     return this.callApi<BlogPostInterface[]>({
       type: Modules.BlogPost,
       method: HttpMethod.GET,

package/src/features/blog/hooks/__tests__/useBlogPostTableStructure.sort.spec.tsx

@@ -0,0 +1,19 @@
+import { renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { BlogPostFields } from "../../data";
+import { useBlogPostTableStructure } from "../useBlogPostTableStructure";
+
+vi.mock("next-intl", () => ({ useTranslations: () => (key: string) => key, useLocale: () => "en" }));
+vi.mock("../useBlogCategoryNames", () => ({ useBlogCategoryNames: () => () => "" }));
+
+/** Spec row A14: status, publishedAt. Only an explicit `enableSorting: true` opts a column in (call C3). */
+describe("useBlogPostTableStructure sorting", () => {
+  it("opts in exactly the row's sortable columns", () => {
+    const { result } = renderHook(() =>
+      useBlogPostTableStructure({ data: [], fields: Object.values(BlogPostFields) as any }),
+    );
+    const columns = result.current.columns as any[];
+    const sortable = columns.filter((column) => column.enableSorting === true).map((column) => column.id);
+    expect(sortable.sort()).toEqual(["publishedAt", "status"]);
+  });
+});

package/src/features/blog/hooks/useBlogPostTableStructure.tsx

@@ -62,7 +62,7 @@ export const useBlogPostTableStructure: UseTableStructureHook<BlogPostInterface,
         }[post.status];
         return <Badge variant={BLOG_STATUS_BADGE[post.status] ?? "softGray"}>{label ?? post.status}</Badge>;
       },
-      enableSorting: false,
+      enableSorting: true,
       enableHiding: false,
     }),
     [BlogPostFields.categories]: () => ({
@@ -87,7 +87,7 @@ export const useBlogPostTableStructure: UseTableStructureHook<BlogPostInterface,
         if (!post.publishedAt) return <span className="text-muted-foreground text-xs">—</span>;
         return <span className="text-xs tabular-nums">{dates.format(post.publishedAt, "dateMedium")}</span>;
       },
-      enableSorting: false,
+      enableSorting: true,
       enableHiding: false,
     }),
     [BlogPostFields.languages]: () => ({

package/src/features/company/components/lists/CompaniesList.tsx

@@ -26,6 +26,8 @@ export function CompaniesList({ fullWidth }: CompaniesListProps = {}) {
     retriever: (params) => CompanyService.findMany(params),
     retrieverParams: {},
     module: Modules.Company,
+    // Display only (call C8): the server's own order when no sort is chosen.
+    defaultSort: "name",
   });
 
   const functions: ReactNode[] = [<CompanyEditor key="create-account" />];

package/src/features/company/data/company.service.ts

@@ -11,11 +11,13 @@ export class CompanyService extends AbstractService {
     });
   }
 
-  static async findMany(params: { search?: string; next?: NextRef }): Promise<CompanyInterface[]> {
+  static async findMany(params: { search?: string; next?: NextRef; sort?: string }): Promise<CompanyInterface[]> {
     const endpoint = new EndpointCreator({ endpoint: Modules.Company });
 
     if (params.search) endpoint.addAdditionalParam("search", params.search);
 
+    if (params.sort) endpoint.addAdditionalParam("sort", params.sort);
+
     return this.callApi<CompanyInterface[]>({
       type: Modules.Company,
       method: HttpMethod.GET,

package/src/features/company/hooks/__tests__/useCompanyTableStructure.sort.spec.tsx

@@ -0,0 +1,19 @@
+import { renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { CompanyFields } from "../../data";
+import { useCompanyTableStructure } from "../useCompanyTableStructure";
+
+vi.mock("next-intl", () => ({ useTranslations: () => (key: string) => key, useLocale: () => "en" }));
+vi.mock("../../../user/contexts", () => ({ useCurrentUserContext: () => ({ currentUser: undefined }) }));
+
+/** Spec row A24: name. Only an explicit `enableSorting: true` opts a column in (call C3). */
+describe("useCompanyTableStructure sorting", () => {
+  it("opts in exactly the row's sortable columns", () => {
+    const { result } = renderHook(() =>
+      useCompanyTableStructure({ data: [], fields: Object.values(CompanyFields) as any }),
+    );
+    const columns = result.current.columns as any[];
+    const sortable = columns.filter((column) => column.enableSorting === true).map((column) => column.id);
+    expect(sortable.sort()).toEqual(["name"]);
+  });
+});

package/src/features/company/hooks/useCompanyTableStructure.tsx

@@ -60,7 +60,7 @@ export const useCompanyTableStructure: UseTableStructureHook<CompanyInterface, C
           </Link>
         );
       },
-      enableSorting: false,
+      enableSorting: true,
       enableHiding: false,
     }),
     [CompanyFields.createdAt]: () =>

package/src/features/content/data/content.service.ts

@@ -8,6 +8,8 @@ export class ContentService extends AbstractService {
     fetchAll?: boolean;
     next?: NextRef;
     prev?: PreviousRef;
+    /** JSON:API `sort` (`name`, `-name`), forwarded to the API. */
+    sort?: string;
   }): Promise<ContentInterface[]> {
     const endpoint = new EndpointCreator({ endpoint: Modules.Content });
 
@@ -21,6 +23,8 @@ export class ContentService extends AbstractService {
     if (Modules.Content.inclusions?.lists?.fields) endpoint.limitToFields(Modules.Content.inclusions.lists.fields);
     if (Modules.Content.inclusions?.lists?.types) endpoint.limitToType(Modules.Content.inclusions.lists.types);
 
+    if (params.sort) endpoint.addAdditionalParam("sort", params.sort);
+
     return this.callApi({
       type: Modules.Content,
       method: HttpMethod.GET,
@@ -29,7 +33,12 @@ export class ContentService extends AbstractService {
     });
   }
 
-  static async findRelevant(params: { id: string; next?: NextRef; prev?: PreviousRef }): Promise<ContentInterface[]> {
+  static async findRelevant(params: {
+    id: string;
+    next?: NextRef;
+    prev?: PreviousRef;
+    sort?: string;
+  }): Promise<ContentInterface[]> {
     const endpoint: EndpointCreator = new EndpointCreator({
       endpoint: Modules.Content,
       id: params.id,
@@ -39,6 +48,8 @@ export class ContentService extends AbstractService {
     if (Modules.Content.inclusions?.lists?.fields) endpoint.limitToFields(Modules.Content.inclusions.lists.fields);
     if (Modules.Content.inclusions?.lists?.types) endpoint.limitToType(Modules.Content.inclusions.lists.types);
 
+    if (params.sort) endpoint.addAdditionalParam("sort", params.sort);
+
     return this.callApi<ContentInterface[]>({
       type: Modules.Content,
       method: HttpMethod.GET,

package/src/features/content/hooks/__tests__/useContentTableStructure.sort.spec.tsx

@@ -0,0 +1,21 @@
+import { renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+// Loads the core barrel first, as the app does: the hook reaches it through the components barrel,
+// which on its own resolves a model module before its base class (circular import).
+import "../../../../core";
+import { ContentFields } from "../../data";
+import { useContentTableStructure } from "../useContentTableStructure";
+
+vi.mock("next-intl", () => ({ useTranslations: () => (key: string) => key, useLocale: () => "en" }));
+
+/** Spec rows A7, A10: name. Only an explicit `enableSorting: true` opts a column in (call C3). */
+describe("useContentTableStructure sorting", () => {
+  it("opts in exactly the row's sortable columns", () => {
+    const { result } = renderHook(() =>
+      useContentTableStructure({ data: [], fields: Object.values(ContentFields) as any }),
+    );
+    const columns = result.current.columns as any[];
+    const sortable = columns.filter((column) => column.enableSorting === true).map((column) => column.id);
+    expect(sortable.sort()).toEqual(["name"]);
+  });
+});

package/src/features/content/hooks/useContentTableStructure.tsx

@@ -58,7 +58,7 @@ export const useContentTableStructure = <U extends string = ContentFields>(
           </Tooltip>
         );
       },
-      enableSorting: false,
+      enableSorting: true,
       enableHiding: false,
     }),
     [ContentFields.relevance]: () => ({

package/src/features/email-automation/components/lists/EmailAutomationRecipientsList.tsx

@@ -28,6 +28,8 @@ export function EmailAutomationRecipientsList() {
     retriever: (params) => EmailAutomationService.findEnrollments(params),
     retrieverParams: { automationId: automation?.id },
     module: Modules.EmailAutomationEnrollment,
+    // Display only (call C8): the server's own order when no sort is chosen.
+    defaultSort: "-enrolledAt",
   });
 
   const handleStatusChange = (value: string | null) => {