@btst/stack 5.0.0 → 5.2.0

package/dist/plugins/cms/client/hooks/index.d.ts

@@ -1,5 +1,6 @@
 import { ResourceFormConfig, ResourceFormResult, ResourceSelectResult } from '@btst/stack/plugins/client/hooks';
-import { a as SerializedContentItemWithType, S as SerializedContentType, I as InverseRelation } from '../../../../shared/stack.3rxARhgS.js';
+import { b as SerializedContentItemWithType, S as SerializedContentType, e as CMSContentTypeMap, I as InverseRelation } from '../../../../shared/stack.DrB3L7Ih.js';
+import { CMSReadView, CMSContentFields, CMSReadOptions, CMSContentItemResult } from '../../api/index.js';
 import 'zod';
 
 interface UseContentTypesResult {
@@ -32,7 +33,7 @@ declare function useContentType(slug: string): {
     error: Error | null;
     refetch: () => void;
 };
-interface UseContentOptions {
+interface UseContentOptions<TView extends CMSReadView = CMSReadView, TFields extends CMSContentFields = CMSContentFields> extends CMSReadOptions<TView, TFields> {
     /** Number of items per page (default: 10) */
     limit?: number;
     /** Whether to enable the query (default: true) */
@@ -44,9 +45,9 @@ interface UseContentOptions {
  * Result type for useContent hook with load more functionality
  * @template TData - The type of parsedData (defaults to Record<string, unknown>)
  */
-interface UseContentResult<TData = Record<string, unknown>> {
+interface UseContentResult<TData = Record<string, unknown>, TView extends CMSReadView = undefined, TFields extends CMSContentFields = undefined> {
     /** Array of all loaded content items */
-    items: SerializedContentItemWithType<TData>[];
+    items: CMSContentItemResult<TData, TView, TFields>[];
     /** Total number of items available */
     total: number;
     /** Whether the initial load is in progress */
@@ -84,21 +85,38 @@ interface UseContentResult<TData = Record<string, unknown>> {
  * // items[0].parsedData.price is number
  * ```
  */
-declare function useContent<TMap extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, options?: UseContentOptions): UseContentResult<TMap[TSlug]>;
+declare function useContent<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, const TFields extends readonly string[] = readonly string[]>(typeSlug: TSlug & string, options: UseContentOptions<"content", TFields> & {
+    view: "content";
+    fields: TFields;
+}): UseContentResult<TMap[TSlug], "content", TFields>;
+declare function useContent<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, options: UseContentOptions<"content"> & {
+    view: "content";
+    fields?: undefined;
+}): UseContentResult<TMap[TSlug], "content">;
+declare function useContent<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, TView extends CMSReadView = undefined, TFields extends CMSContentFields = undefined>(typeSlug: TSlug & string, options?: UseContentOptions<TView, TFields>): UseContentResult<TMap[TSlug], TView, TFields>;
 /**
  * Suspense variant of useContent with load more functionality.
  *
  * @template TMap - A type map of content type slugs to their data types
  * @template TSlug - The content type slug (inferred from typeSlug parameter)
  */
-declare function useSuspenseContent<TMap extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, options?: UseContentOptions): {
-    items: SerializedContentItemWithType<TMap[TSlug]>[];
+type SuspenseContentResult<TData, TView extends CMSReadView, TFields extends CMSContentFields = undefined> = {
+    items: CMSContentItemResult<TData, TView, TFields>[];
     total: number;
     loadMore: () => Promise<unknown>;
     hasMore: boolean;
     isLoadingMore: boolean;
     refetch: () => Promise<unknown>;
 };
+declare function useSuspenseContent<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, const TFields extends readonly string[] = readonly string[]>(typeSlug: TSlug & string, options: UseContentOptions<"content", TFields> & {
+    view: "content";
+    fields: TFields;
+}): SuspenseContentResult<TMap[TSlug], "content", TFields>;
+declare function useSuspenseContent<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, options: UseContentOptions<"content"> & {
+    view: "content";
+    fields?: undefined;
+}): SuspenseContentResult<TMap[TSlug], "content">;
+declare function useSuspenseContent<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, TView extends CMSReadView = undefined, TFields extends CMSContentFields = undefined>(typeSlug: TSlug & string, options?: UseContentOptions<TView, TFields>): SuspenseContentResult<TMap[TSlug], TView, TFields>;
 /**
  * Hook for fetching a single content item by ID with optional type safety.
  *
@@ -112,22 +130,40 @@ declare function useSuspenseContent<TMap extends Record<string, Record<string, u
  * // item?.parsedData.name is string
  * ```
  */
-declare function useContentItem<TMap extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, id: string): {
-    item: SerializedContentItemWithType<TMap[TSlug]> | null;
+type ContentItemQueryResult<TData, TView extends CMSReadView, TFields extends CMSContentFields = undefined> = {
+    item: CMSContentItemResult<TData, TView, TFields> | null;
     isLoading: boolean;
     error: Error | null;
     refetch: () => void;
 };
+declare function useContentItem<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, const TFields extends readonly string[] = readonly string[]>(typeSlug: TSlug & string, id: string, options: CMSReadOptions<"content", TFields> & {
+    view: "content";
+    fields: TFields;
+}): ContentItemQueryResult<TMap[TSlug], "content", TFields>;
+declare function useContentItem<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, id: string, options: CMSReadOptions<"content"> & {
+    view: "content";
+    fields?: undefined;
+}): ContentItemQueryResult<TMap[TSlug], "content">;
+declare function useContentItem<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, TView extends CMSReadView = undefined, TFields extends CMSContentFields = undefined>(typeSlug: TSlug & string, id: string, options?: CMSReadOptions<TView, TFields>): ContentItemQueryResult<TMap[TSlug], TView, TFields>;
 /**
  * Suspense variant of useContentItem with optional type safety.
  *
  * @template TMap - A type map of content type slugs to their data types
  * @template TSlug - The content type slug (inferred from typeSlug parameter)
  */
-declare function useSuspenseContentItem<TMap extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, id: string): {
-    item: SerializedContentItemWithType<TMap[TSlug]> | null;
+type SuspenseContentItemResult<TData, TView extends CMSReadView, TFields extends CMSContentFields = undefined> = {
+    item: CMSContentItemResult<TData, TView, TFields> | null;
     refetch: () => Promise<unknown>;
 };
+declare function useSuspenseContentItem<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, const TFields extends readonly string[] = readonly string[]>(typeSlug: TSlug & string, id: string, options: CMSReadOptions<"content", TFields> & {
+    view: "content";
+    fields: TFields;
+}): SuspenseContentItemResult<TMap[TSlug], "content", TFields>;
+declare function useSuspenseContentItem<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, id: string, options: CMSReadOptions<"content"> & {
+    view: "content";
+    fields?: undefined;
+}): SuspenseContentItemResult<TMap[TSlug], "content">;
+declare function useSuspenseContentItem<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, TView extends CMSReadView = undefined, TFields extends CMSContentFields = undefined>(typeSlug: TSlug & string, id: string, options?: CMSReadOptions<TView, TFields>): SuspenseContentItemResult<TMap[TSlug], TView, TFields>;
 /**
  * Hook for fetching a content item by slug with optional type safety.
  *
@@ -141,12 +177,15 @@ declare function useSuspenseContentItem<TMap extends Record<string, Record<strin
  * // item?.parsedData.price is number
  * ```
  */
-declare function useContentItemBySlug<TMap extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, slug: string): {
-    item: SerializedContentItemWithType<TMap[TSlug]> | null;
-    isLoading: boolean;
-    error: Error | null;
-    refetch: () => void;
-};
+declare function useContentItemBySlug<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, const TFields extends readonly string[] = readonly string[]>(typeSlug: TSlug & string, slug: string, options: CMSReadOptions<"content", TFields> & {
+    view: "content";
+    fields: TFields;
+}): ContentItemQueryResult<TMap[TSlug], "content", TFields>;
+declare function useContentItemBySlug<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, slug: string, options: CMSReadOptions<"content"> & {
+    view: "content";
+    fields?: undefined;
+}): ContentItemQueryResult<TMap[TSlug], "content">;
+declare function useContentItemBySlug<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, TView extends CMSReadView = undefined, TFields extends CMSContentFields = undefined>(typeSlug: TSlug & string, slug: string, options?: CMSReadOptions<TView, TFields>): ContentItemQueryResult<TMap[TSlug], TView, TFields>;
 /**
  * Hook for creating a content item with optional type safety.
  *
@@ -527,15 +566,16 @@ declare function useContentItemForm<TValues>(config: ResourceFormConfig<TValues,
  * query, with selected ids missing from the current results preloaded via
  * the `detail` query (typeSlug, id) so their labels resolve.
  *
- * Used by the relation picker (`RelationField`).
+ * Used by the relation picker (`RelationField`). Optional content view/fields
+ * apply to both search results and selected-ID preloads; full records remain the default.
  */
-declare function useContentOptions(config: {
-    /** Content type slug to search within */
+declare function useContentOptions<TView extends CMSReadView = undefined, const TFields extends CMSContentFields = undefined>(config: {
+    /** Content type slug to search within. */
     targetType: string;
-    /** Currently selected item ids — preloaded when missing from options */
+    /** Currently selected IDs, preloaded when absent from search results. */
     value: string[];
-    getOptionLabel: (item: SerializedContentItemWithType) => string;
-}): ResourceSelectResult<SerializedContentItemWithType>;
+    getOptionLabel: (item: CMSContentItemResult<Record<string, unknown>, TView, TFields>) => string;
+} & CMSReadOptions<TView, TFields>): ResourceSelectResult<CMSContentItemResult<Record<string, unknown>, TView, TFields>>;
 /**
  * Content item with populated relations
  */
@@ -575,7 +615,7 @@ declare function useSuspenseContentItemPopulated<TMap extends Record<string, Rec
 /**
  * Options for useContentByRelation hook
  */
-interface UseContentByRelationOptions {
+interface UseContentByRelationOptions<TView extends CMSReadView = CMSReadView, TFields extends CMSContentFields = CMSContentFields> extends CMSReadOptions<TView, TFields> {
     /** Number of items per page (default: 20) */
     limit?: number;
     /** Whether to enable the query (default: true) */
@@ -594,27 +634,27 @@ interface UseContentByRelationOptions {
  * const { items } = useContentByRelation("resource", "categoryIds", categoryId)
  * ```
  */
-declare function useContentByRelation<TMap extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, fieldName: string, targetId: string, options?: UseContentByRelationOptions): {
-    items: SerializedContentItemWithType<TMap[TSlug]>[];
-    total: number;
-    isLoading: boolean;
-    error: Error | null;
-    loadMore: () => void;
-    hasMore: boolean;
-    isLoadingMore: boolean;
-    refetch: () => void;
-};
+declare function useContentByRelation<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, const TFields extends readonly string[] = readonly string[]>(typeSlug: TSlug & string, fieldName: string, targetId: string, options: UseContentByRelationOptions<"content", TFields> & {
+    view: "content";
+    fields: TFields;
+}): UseContentResult<TMap[TSlug], "content", TFields>;
+declare function useContentByRelation<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, fieldName: string, targetId: string, options: UseContentByRelationOptions<"content"> & {
+    view: "content";
+    fields?: undefined;
+}): UseContentResult<TMap[TSlug], "content">;
+declare function useContentByRelation<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, TView extends CMSReadView = undefined, TFields extends CMSContentFields = undefined>(typeSlug: TSlug & string, fieldName: string, targetId: string, options?: UseContentByRelationOptions<TView, TFields>): UseContentResult<TMap[TSlug], TView, TFields>;
 /**
  * Suspense variant of useContentByRelation
  */
-declare function useSuspenseContentByRelation<TMap extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, fieldName: string, targetId: string, options?: UseContentByRelationOptions): {
-    items: SerializedContentItemWithType<TMap[TSlug]>[];
-    total: number;
-    loadMore: () => Promise<unknown>;
-    hasMore: boolean;
-    isLoadingMore: boolean;
-    refetch: () => Promise<unknown>;
-};
+declare function useSuspenseContentByRelation<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, const TFields extends readonly string[] = readonly string[]>(typeSlug: TSlug & string, fieldName: string, targetId: string, options: UseContentByRelationOptions<"content", TFields> & {
+    view: "content";
+    fields: TFields;
+}): SuspenseContentResult<TMap[TSlug], "content", TFields>;
+declare function useSuspenseContentByRelation<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, fieldName: string, targetId: string, options: UseContentByRelationOptions<"content"> & {
+    view: "content";
+    fields?: undefined;
+}): SuspenseContentResult<TMap[TSlug], "content">;
+declare function useSuspenseContentByRelation<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, TView extends CMSReadView = undefined, TFields extends CMSContentFields = undefined>(typeSlug: TSlug & string, fieldName: string, targetId: string, options?: UseContentByRelationOptions<TView, TFields>): SuspenseContentResult<TMap[TSlug], TView, TFields>;
 /**
  * Hook for fetching the inverse relations of a content item — the content
  * types with belongsTo fields pointing at it, with per-field counts.
@@ -629,15 +669,20 @@ declare function useInverseRelations(contentTypeSlug: string, itemId: string): {
  * Hook for listing the items behind one inverse relation (e.g. all comments
  * whose `resourceId` points at this resource).
  */
-declare function useInverseRelationItems(params: {
+declare function useInverseRelationItems<TView extends CMSReadView = undefined, const TFields extends CMSContentFields = undefined>(params: {
     contentTypeSlug: string;
     sourceType: string;
     itemId: string;
     fieldName: string;
-}, options?: {
+}, options?: CMSReadOptions<TView, TFields> & {
+    /** Whether to enable the query (default: true). */
     enabled?: boolean;
+    /** Number of items per page (default: 20). */
+    limit?: number;
+    /** Number of matching items to skip (default: 0). */
+    offset?: number;
 }): {
-    items: SerializedContentItemWithType[];
+    items: CMSContentItemResult<Record<string, unknown>, TView, TFields>[];
     total: number;
     isLoading: boolean;
     error: Error | null;

package/dist/plugins/cms/client/index.d.cts

@@ -3,7 +3,8 @@ import * as _btst_yar from '@btst/yar';
 import * as react from 'react';
 import { ComponentType } from 'react';
 import { D as DashboardPageComponent } from '../../../shared/stack.C_M5E2GI.cjs';
-import { o as ContentTypeConfig } from '../../../shared/stack.3rxARhgS.cjs';
+import { u as ContentTypeConfig } from '../../../shared/stack.DrB3L7Ih.cjs';
+export { c as CMSContentFields, d as CMSContentItemResult, C as CMSReadOptions, a as CMSReadView, g as CMSSelectedData, P as PaginatedContentItems, v as SerializedContentItemContent } from '../../../shared/stack.DrB3L7Ih.cjs';
 import { A as AutoFormInputComponentProps } from '../../../shared/stack.TOEmfBQ4.cjs';
 export { F as FormSchemaMetadata, a as FormStep, f as formSchemaToZod, g as getStepGroupMap, b as getSteps, h as hasSteps, z as zodToFormSchema } from '../../../shared/stack.611-G_G_.cjs';
 import 'zod';

package/dist/plugins/cms/client/index.d.mts

@@ -3,7 +3,8 @@ import * as _btst_yar from '@btst/yar';
 import * as react from 'react';
 import { ComponentType } from 'react';
 import { D as DashboardPageComponent } from '../../../shared/stack.C_M5E2GI.mjs';
-import { o as ContentTypeConfig } from '../../../shared/stack.3rxARhgS.mjs';
+import { u as ContentTypeConfig } from '../../../shared/stack.DrB3L7Ih.mjs';
+export { c as CMSContentFields, d as CMSContentItemResult, C as CMSReadOptions, a as CMSReadView, g as CMSSelectedData, P as PaginatedContentItems, v as SerializedContentItemContent } from '../../../shared/stack.DrB3L7Ih.mjs';
 import { A as AutoFormInputComponentProps } from '../../../shared/stack.TOEmfBQ4.mjs';
 export { F as FormSchemaMetadata, a as FormStep, f as formSchemaToZod, g as getStepGroupMap, b as getSteps, h as hasSteps, z as zodToFormSchema } from '../../../shared/stack.611-G_G_.mjs';
 import 'zod';

package/dist/plugins/cms/client/index.d.ts

@@ -3,7 +3,8 @@ import * as _btst_yar from '@btst/yar';
 import * as react from 'react';
 import { ComponentType } from 'react';
 import { D as DashboardPageComponent } from '../../../shared/stack.C_M5E2GI.js';
-import { o as ContentTypeConfig } from '../../../shared/stack.3rxARhgS.js';
+import { u as ContentTypeConfig } from '../../../shared/stack.DrB3L7Ih.js';
+export { c as CMSContentFields, d as CMSContentItemResult, C as CMSReadOptions, a as CMSReadView, g as CMSSelectedData, P as PaginatedContentItems, v as SerializedContentItemContent } from '../../../shared/stack.DrB3L7Ih.js';
 import { A as AutoFormInputComponentProps } from '../../../shared/stack.TOEmfBQ4.js';
 export { F as FormSchemaMetadata, a as FormStep, f as formSchemaToZod, g as getStepGroupMap, b as getSteps, h as hasSteps, z as zodToFormSchema } from '../../../shared/stack.611-G_G_.js';
 import 'zod';

package/dist/plugins/cms/query-keys.cjs

@@ -1,11 +1,23 @@
 'use strict';
 
+const schemas = require('../../packages/stack/src/plugins/cms/schemas.cjs');
 const client = require('@btst/stack/plugins/client');
 const queryKeyDefs = require('../../packages/stack/src/plugins/cms/api/query-key-defs.cjs');
 
 function normalizeSearch(search) {
   return search !== void 0 && search.trim() === "" ? void 0 : search;
 }
+function contentReadQuery(options) {
+  return {
+    view: options?.view,
+    fields: options?.fields === void 0 ? void 0 : JSON.stringify(schemas.normalizeContentFields(options.fields))
+  };
+}
+function relationPageKey(params) {
+  const limit = params.limit ?? 20;
+  const offset = params.offset ?? 0;
+  return limit === 20 && offset === 0 && !params.view && params.fields === void 0 ? [] : [{ limit, offset, ...queryKeyDefs.contentReadDiscriminator(params) }];
+}
 function paginatedNextPageParam(lastPage, allPages, limit) {
   const items = Array.isArray(lastPage?.items) ? lastPage.items : [];
   if (items.length < limit) return void 0;
@@ -46,14 +58,18 @@ const cmsResources = {
           sourceType: p.sourceType
         }),
         query: (p) => ({
+          ...contentReadQuery(p),
           itemId: p.itemId,
-          fieldName: p.fieldName
+          fieldName: p.fieldName,
+          limit: p.limit ?? 20,
+          offset: p.offset ?? 0
         }),
         key: (p) => [
           p.slug,
           p.sourceType,
           p.itemId,
-          p.fieldName
+          p.fieldName,
+          ...relationPageKey(p)
         ],
         select: (data) => data ?? { items: [], total: 0 }
       }
@@ -65,6 +81,7 @@ const cmsResources = {
         path: "/content/:typeSlug",
         params: (p) => ({ typeSlug: p.typeSlug }),
         query: (p) => ({
+          ...contentReadQuery(p),
           limit: p.limit ?? 20,
           search: normalizeSearch(p.search)
         }),
@@ -76,16 +93,33 @@ const cmsResources = {
       },
       detail: {
         path: "/content/:typeSlug/:id",
-        params: (typeSlug, id) => ({ typeSlug, id }),
-        key: (typeSlug, id) => [typeSlug, id],
-        select: (data, _typeSlug, _id) => data ?? null,
+        params: (typeSlug, id, _options) => ({
+          typeSlug,
+          id
+        }),
+        query: (_typeSlug, _id, options) => contentReadQuery(options),
+        key: (typeSlug, id, options) => [
+          typeSlug,
+          id,
+          ...queryKeyDefs.contentReadKey(options)
+        ],
+        select: (data, _typeSlug, _id, _options) => data ?? null,
         skip: (typeSlug, id) => !typeSlug || !id
       },
       bySlug: {
         path: "/content/:typeSlug",
-        params: (typeSlug, _slug) => ({ typeSlug }),
-        query: (_typeSlug, slug) => ({ slug, limit: 1 }),
-        key: (typeSlug, slug) => ["bySlug", typeSlug, slug],
+        params: (typeSlug, _slug, _options) => ({ typeSlug }),
+        query: (_typeSlug, slug, options) => ({
+          slug,
+          limit: 1,
+          ...contentReadQuery(options)
+        }),
+        key: (typeSlug, slug, options) => [
+          "bySlug",
+          typeSlug,
+          slug,
+          ...queryKeyDefs.contentReadKey(options)
+        ],
         select: (data) => data?.items?.[0] ?? null,
         skip: (typeSlug, slug) => !typeSlug || !slug
       },
@@ -100,11 +134,17 @@ const cmsResources = {
         path: "/content/:typeSlug/by-relation",
         params: (p) => ({ typeSlug: p.typeSlug }),
         query: (p) => ({
+          ...contentReadQuery(p),
           field: p.field,
           targetId: p.targetId,
           limit: p.limit ?? 20
         }),
-        key: (p) => [p.typeSlug, p.field, p.targetId],
+        key: (p) => [
+          p.typeSlug,
+          p.field,
+          p.targetId,
+          ...relationPageKey(p)
+        ],
         select: (data, _p) => data,
         infinite: true,
         pageSize: (p) => p.limit ?? 20,
@@ -115,6 +155,7 @@ const cmsResources = {
         path: "/content/:typeSlug",
         params: (p) => ({ typeSlug: p.typeSlug }),
         query: (p) => ({
+          ...contentReadQuery(p),
           search: normalizeSearch(p.search),
           limit: p.limit ?? 50
         }),
@@ -122,7 +163,8 @@ const cmsResources = {
           "options",
           p.typeSlug,
           normalizeSearch(p.search),
-          p.limit ?? 50
+          p.limit ?? 50,
+          ...queryKeyDefs.contentReadKey(p)
         ],
         select: (data, _p) => data?.items ?? []
       }
@@ -136,7 +178,12 @@ const cmsResources = {
           body: { slug: vars.slug, data: vars.data }
         }),
         select: (data) => data,
-        invalidates: ["cmsContent.list", "cmsTypes.list"]
+        invalidates: [
+          "cmsContent",
+          "cmsTypes.list",
+          "cmsTypes.inverseRelationItems",
+          "cmsTypes.inverseRelations"
+        ]
       },
       update: {
         path: "@put/content/:typeSlug/:id",
@@ -146,7 +193,11 @@ const cmsResources = {
           body: vars.data
         }),
         select: (data) => data,
-        invalidates: ["cmsContent.list"],
+        invalidates: [
+          "cmsContent",
+          "cmsTypes.inverseRelationItems",
+          "cmsTypes.inverseRelations"
+        ],
         setData: {
           query: "detail",
           args: (updated) => updated?.contentType?.slug ? [updated.contentType.slug, updated.id] : null
@@ -159,7 +210,12 @@ const cmsResources = {
           params: { typeSlug: vars.typeSlug, id: vars.id }
         }),
         select: (data) => data,
-        invalidates: ["cmsContent", "cmsTypes.list"]
+        invalidates: [
+          "cmsContent",
+          "cmsTypes.list",
+          "cmsTypes.inverseRelationItems",
+          "cmsTypes.inverseRelations"
+        ]
       }
     }
   }