feat: add depth selection for actions (#470)

.changeset/dry-tips-thank.md

@@ -0,0 +1,5 @@
+---
+"@premieroctet/next-admin": patch
+---
+
+feat: add depth selection for actions (#443)

apps/docs/pages/docs/api/model-configuration.mdx

@@ -652,6 +652,12 @@ The `actions` property is an array of objects that allows you to define a set of
       description:
         "a message that will be displayed when the action fails if action doesn't return a message object or throw an error with a message",
     },
+    {
+      name: "depth",
+      type: "Number",
+      description:
+        "a number that defines the depth of the relations to select in the resource. Use this with caution, a number too high can potentially cause slower queries. Defaults to 2.",
+    },
   ]}
 />
 

apps/example/options.tsx

@@ -189,6 +189,7 @@ export const options: NextAdminOptions = {
           id: "user-details",
           title: "actions.user.details.title",
           component: <UserDetailsDialog />,
+          depth: 3,
         },
       ],
     },

packages/next-admin/src/appHandler.ts

@@ -58,11 +58,25 @@ export const createHandler = <P extends string = "nextadmin">({
         ?.split(",")
         .map((id) => formatId(resource, id));
 
+      const depth = req.nextUrl.searchParams.get("depth");
+
       if (!ids) {
         return NextResponse.json({ error: "No ids provided" }, { status: 400 });
       }
 
-      const data = await getRawData({ prisma, resource, resourceIds: ids });
+      if (depth && isNaN(Number(depth))) {
+        return NextResponse.json(
+          { error: "Depth should be a number" },
+          { status: 400 }
+        );
+      }
+
+      const data = await getRawData({
+        prisma,
+        resource,
+        resourceIds: ids,
+        maxDepth: depth ? Number(depth) : undefined,
+      });
 
       return NextResponse.json(data);
     })

packages/next-admin/src/components/ClientActionDialog.tsx

@@ -42,9 +42,16 @@ const ClientActionDialog = <M extends ModelName>({
 
   useEffect(() => {
     setIsLoading(true);
-    fetch(
-      `${apiBasePath}/${slugify(resource)}/raw?ids=${resourceIds.join(",")}`
-    )
+    const params = new URLSearchParams();
+
+    params.set("ids", resourceIds.join(","));
+
+    if (action.depth) {
+      // Avoid negative depth
+      params.set("depth", Math.max(1, action.depth).toString());
+    }
+
+    fetch(`${apiBasePath}/${slugify(resource)}/raw?${params.toString()}`)
       .then((res) => res.json())
       .then(setData)
       .finally(() => {

packages/next-admin/src/pageHandler.ts

@@ -90,7 +90,18 @@ export const createHandler = <P extends string = "nextadmin">({
         ids = ids?.split(",").map((id: string) => formatId(resource, id));
       }
 
-      const data = await getRawData({ prisma, resource, resourceIds: ids });
+      const depth = req.query.depth;
+
+      if (depth && isNaN(Number(depth))) {
+        return res.status(400).json({ error: "Depth should be a number" });
+      }
+
+      const data = await getRawData({
+        prisma,
+        resource,
+        resourceIds: ids,
+        maxDepth: depth ? Number(depth) : undefined,
+      });
 
       return res.json(data);
     })

packages/next-admin/src/types.ts

@@ -549,6 +549,12 @@ export type BareModelAction<M extends ModelName> = {
   canExecute?: (item: Model<M>) => boolean;
   icon?: keyof typeof OutlineIcons;
   style?: ActionStyle;
+  /**
+   * Max depth of the related records to select
+   *
+   * @default 2
+   */
+  depth?: number;
 };
 
 export type ServerAction = {

packages/next-admin/src/utils/prisma.ts

@@ -661,6 +661,38 @@ export const getDataItem = async <M extends ModelName>({
   return data;
 };
 
+type DeepIncludeRecord = Record<string, true | any>;
+
+const includeDataByDepth = <M extends ModelName>(
+  model: Prisma.DMMF.Model,
+  currentDepth: number,
+  maxDepth: number
+) => {
+  const include = model?.fields.reduce((acc, field) => {
+    if (field.kind === "object") {
+      /**
+       * We substract because, if the condition matches,
+       * we will have all the fields in the related model, which are
+       * counted in currentDepth + 1
+       */
+      if (currentDepth < maxDepth - 1) {
+        acc[field.name] = {
+          include: includeDataByDepth(
+            getPrismaModelForResource(field.type as M)!,
+            currentDepth + 1,
+            maxDepth
+          ),
+        };
+      } else {
+        acc[field.name] = true;
+      }
+    }
+    return acc;
+  }, {} as DeepIncludeRecord);
+
+  return include;
+};
+
 /**
  * Get raw data from Prisma (2-deep nested relations)
  * @param prisma
@@ -672,22 +704,16 @@ export const getRawData = async <M extends ModelName>({
   prisma,
   resource,
   resourceIds,
+  maxDepth = 2,
 }: {
   prisma: PrismaClient;
   resource: M;
   resourceIds: Array<string | number>;
+  maxDepth?: number;
 }): Promise<Model<M>[]> => {
   const modelDMMF = getPrismaModelForResource(resource);
 
-  const include = modelDMMF?.fields.reduce(
-    (acc, field) => {
-      if (field.kind === "object") {
-        acc[field.name] = true;
-      }
-      return acc;
-    },
-    {} as Record<string, true>
-  );
+  const include = includeDataByDepth(modelDMMF!, 1, maxDepth);
 
   // @ts-expect-error
   const data = await prisma[resource].findMany({

packages/next-admin/src/utils/server.ts

@@ -50,10 +50,14 @@ export const getEnableToExecuteActions = async <M extends ModelName>(
   actions?: Omit<ModelAction<M>, "action">[]
 ): Promise<OutputModelAction | undefined> => {
   if (actions?.some((action) => action.canExecute)) {
+    const maxDepth = Math.max(0, ...actions.map((action) => action.depth ?? 0));
+
     const data: Model<typeof resource>[] = await getRawData<typeof resource>({
       prisma,
       resource,
       resourceIds: ids,
+      // Apply the default value if its 0
+      maxDepth: maxDepth || undefined,
     });
 
     return actions?.reduce(