extract common helper for processNestedSingleRead and processSingleRead

Author: lsmith77

packages/server/src/api/rest/index.ts

@@ -809,18 +809,16 @@ export class RestApiHandler<Schema extends SchemaDef = SchemaDef> implements Api
         return resp;
     }
 
-    private async processSingleRead(
-        client: ClientContract<Schema>,
+    /**
+     * Builds the ORM `args` object (include, select) shared by single-read operations.
+     * Returns the args to pass to findUnique/findFirst and the resolved `include` list for serialization,
+     * or an error response if query params are invalid.
+     */
+    private buildSingleReadArgs(
         type: string,
-        resourceId: string,
         query: Record<string, string | string[]> | undefined,
-    ): Promise<Response> {
-        const typeInfo = this.getModelInfo(type);
-        if (!typeInfo) {
-            return this.makeUnsupportedModelError(type);
-        }
-
-        const args: any = { where: this.makeIdFilter(typeInfo.idFields, resourceId) };
+    ): { args: any; include: string[] | undefined; error?: Response } {
+        const args: any = {};
 
         // include IDs of relation fields so that they can be serialized
         this.includeRelationshipIds(type, args, 'include');
@@ -830,7 +828,7 @@ export class RestApiHandler<Schema extends SchemaDef = SchemaDef> implements Api
         if (query?.['include']) {
             const { select, error, allIncludes } = this.buildRelationSelect(type, query['include'], query);
             if (error) {
-                return error;
+                return { args, include, error };
             }
             if (select) {
                 args.include = { ...args.include, ...select };
@@ -840,18 +838,34 @@ export class RestApiHandler<Schema extends SchemaDef = SchemaDef> implements Api
 
         // handle partial results for requested type
         const { select, error } = this.buildPartialSelect(type, query);
-        if (error) return error;
+        if (error) return { args, include, error };
         if (select) {
             args.select = { ...select, ...args.select };
             if (args.include) {
-                args.select = {
-                    ...args.select,
-                    ...args.include,
-                };
+                args.select = { ...args.select, ...args.include };
                 args.include = undefined;
             }
         }
 
+        return { args, include };
+    }
+
+    private async processSingleRead(
+        client: ClientContract<Schema>,
+        type: string,
+        resourceId: string,
+        query: Record<string, string | string[]> | undefined,
+    ): Promise<Response> {
+        const typeInfo = this.getModelInfo(type);
+        if (!typeInfo) {
+            return this.makeUnsupportedModelError(type);
+        }
+
+        const { args, include, error } = this.buildSingleReadArgs(type, query);
+        if (error) return error;
+
+        args.where = this.makeIdFilter(typeInfo.idFields, resourceId);
+
         const entity = await (client as any)[type].findUnique(args);
 
         if (entity) {
@@ -1161,28 +1175,10 @@ export class RestApiHandler<Schema extends SchemaDef = SchemaDef> implements Api
         const childType = resolved.childType;
         const typeInfo = this.getModelInfo(childType)!;
 
-        const args: any = {
-            where: this.mergeFilters(this.makeIdFilter(typeInfo.idFields, childId), nestedFilter),
-        };
-        this.includeRelationshipIds(childType, args, 'include');
-
-        let include: string[] | undefined;
-        if (query?.['include']) {
-            const { select, error, allIncludes } = this.buildRelationSelect(childType, query['include'], query);
-            if (error) return error;
-            if (select) args.include = { ...args.include, ...select };
-            include = allIncludes;
-        }
-
-        const { select, error } = this.buildPartialSelect(childType, query);
+        const { args, include, error } = this.buildSingleReadArgs(childType, query);
         if (error) return error;
-        if (select) {
-            args.select = { ...select, ...args.select };
-            if (args.include) {
-                args.select = { ...args.select, ...args.include };
-                args.include = undefined;
-            }
-        }
+
+        args.where = this.mergeFilters(this.makeIdFilter(typeInfo.idFields, childId), nestedFilter);
 
         const entity = await (client as any)[childType].findFirst(args);
         if (!entity) return this.makeError('notFound');