Merge pull request #160 from fleetbase/dev-v1.6.18

added `without` feature to resources

Author: roncodes

src/Http/Resources/FleetbaseResource.php

@@ -4,10 +4,18 @@
 
 use Fleetbase\Support\Http;
 use Illuminate\Http\Resources\Json\JsonResource;
+use Illuminate\Support\Arr;
 use Illuminate\Support\Str;
 
 class FleetbaseResource extends JsonResource
 {
+    /**
+     * List of attributes to exclude from the final array.
+     *
+     * @var array
+     */
+    protected array $excluded = [];
+
     /**
      * Transform the resource into an array.
      *
@@ -17,9 +25,10 @@ class FleetbaseResource extends JsonResource
      */
     public function toArray($request)
     {
-        $resource = parent::toArray($request);
+        $data = parent::toArray($request);
+        $data = $this->filterExcluded($data);
 
-        return $resource;
+        return $data;
     }
 
     /**
@@ -65,4 +74,36 @@ public function getInternalIds(): array
 
         return $internalIds;
     }
+
+    /**
+     * Exclude one or more keys from serialization.
+     *
+     * @param  array|string  $keys
+     * @return static
+     */
+    public function without(array|string $keys): static
+    {
+        $clone = clone $this;
+        $clone->excluded = array_merge($this->excluded, (array) $keys);
+
+        return $clone;
+    }
+
+    /**
+     * Remove excluded keys recursively.
+     */
+    protected function filterExcluded(array $data): array
+    {
+        foreach ($this->excluded as $key) {
+            Arr::forget($data, $key);
+        }
+
+        foreach ($data as $k => $v) {
+            if (is_array($v)) {
+                $data[$k] = $this->filterExcluded($v);
+            }
+        }
+
+        return $data;
+    }
 }

src/Http/Resources/FleetbaseResourceCollection.php

@@ -4,35 +4,135 @@
 
 use Fleetbase\Http\Resources\Json\FleetbasePaginatedResourceResponse;
 use Illuminate\Http\Resources\Json\ResourceCollection;
+use Illuminate\Support\Arr;
 
+/**
+ * FleetbaseResourceCollection
+ *
+ * Usage:
+ *   return (new FleetbaseResourceCollection($paginator, Order::class))
+ *       ->without(['place', 'places', 'payload.places', 'owner.places']);
+ *
+ * Notes:
+ * - Exclusions are instance-scoped (affect only this response).
+ * - Dot-notation is supported (e.g., 'payload.places', 'customer.address.street').
+ * - If items are plain models/arrays, they’ll be wrapped with $collects (resource class)
+ *   and exclusions applied to the resolved array.
+ * - If items are already resources and implement ->without(), that will be used.
+ */
 class FleetbaseResourceCollection extends ResourceCollection
 {
     /**
      * The name of the resource being collected.
      *
-     * @var string
+     * @var class-string|null
      */
     public $collects;
 
     /**
-     * Create a new anonymous resource collection.
+     * Keys to exclude from each item's serialized array (dot-notation supported).
      *
-     * @param string $collects
+     * @var array<int, string>
+     */
+    protected array $excluded = [];
+
+    /**
+     * Create a new resource collection.
      *
+     * @param  mixed               $resource  A paginator, array, or collection
+     * @param  class-string|null   $collects  Fully-qualified resource class for items
      * @return void
      */
-    public function __construct($resource, $collects)
+    public function __construct($resource, $collects = null)
     {
         $this->collects = $collects;
 
         parent::__construct($resource);
     }
 
     /**
-     * Create a paginate-aware HTTP response.
+     * Exclude one or more keys from every item in this collection.
+     *
+     * @param  array<string>|string  $keys
+     * @return static
+     */
+    public function without(array|string $keys): static
+    {
+        $clone = clone $this;
+        $clone->excluded = array_values(array_unique(array_merge($this->excluded, (array) $keys)));
+
+        return $clone;
+    }
+
+    /**
+     * Convert the resource collection into an array.
+     *
+     * Applies the exclusion list to every item. If items are not already resources,
+     * they are wrapped using the $collects class (if provided).
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return array<int, mixed>
+     */
+    public function toArray($request): array
+    {
+        return $this->collection->map(function ($item) use ($request) {
+            // If the item is already a resource and has ->without(), use it.
+            if (is_object($item) && method_exists($item, 'toArray')) {
+                if (method_exists($item, 'without')) {
+                    /** @var object $item */
+                    $array = $item->without($this->excluded)->toArray($request);
+                    return $this->applyArrayExclusions($array);
+                }
+
+                // Otherwise, just resolve it to array and then filter.
+                $array = $item->toArray($request);
+                return $this->applyArrayExclusions($array);
+            }
+
+            // If $collects is set, wrap the raw item in the resource class.
+            if (is_string($this->collects) && class_exists($this->collects)) {
+                $resource = new $this->collects($item);
+
+                if (method_exists($resource, 'without')) {
+                    $array = $resource->without($this->excluded)->toArray($request);
+                } else {
+                    $array = $resource->toArray($request);
+                    $array = $this->applyArrayExclusions($array);
+                }
+
+                return $array;
+            }
+
+            // Fallback: treat as plain array/object and filter keys.
+            $array = is_array($item) ? $item : (array) $item;
+
+            return $this->applyArrayExclusions($array);
+        })->all();
+    }
+
+    /**
+     * Apply the exclusion list to an array using dot-notation.
      *
-     * @param \Illuminate\Http\Request $request
+     * @param  array<string, mixed>  $array
+     * @return array<string, mixed>
+     */
+    protected function applyArrayExclusions(array $array): array
+    {
+        if (empty($this->excluded)) {
+            return $array;
+        }
+
+        foreach ($this->excluded as $key) {
+            Arr::forget($array, $key);
+        }
+
+        return $array;
+    }
+
+    /**
+     * Create a paginate-aware HTTP response (unchanged from your original).
      *
+     * @param  \Illuminate\Http\Request  $request
      * @return \Illuminate\Http\JsonResponse
      */
     protected function preparePaginatedResponse($request)
@@ -45,4 +145,4 @@ protected function preparePaginatedResponse($request)
 
         return (new FleetbasePaginatedResourceResponse($this))->toResponse($request);
     }
-}
+}