Documentation Index
Fetch the complete documentation index at: https://mintlify.com/charlietyn/rest-generic-class/llms.txt
Use this file to discover all available pages before exploring further.
Overview
The Objectify class provides utility methods for converting JSON strings to PHP arrays. It includes support for recursive mapping and handling arrays of JSON strings.
Class Reference
use Ronu\RestGenericClass\Core\Helpers\Objectify;
Methods
json_mapper()
Decode JSON strings to arrays with optional recursive processing.
public function json_mapper($value, $recursive = true): mixed
The value to process. Can be:
- JSON string: Will be decoded to array
- Array: Will recursively process each element (if
$recursive is true)
- Other: Returns unchanged
Whether to recursively process array elements
- Decoded array if input is valid JSON string
- Recursively processed array if input is array and
$recursive is true
- Original value if not JSON or array
Example Usage
$objectify = new Objectify();
// Decode single JSON string
$json = '{"name":"John","age":30}';
$result = $objectify->json_mapper($json);
// ['name' => 'John', 'age' => 30]
// Decode array of JSON strings (recursive)
$jsonArray = [
'{"id":1,"name":"John"}',
'{"id":2,"name":"Jane"}',
];
$result = $objectify->json_mapper($jsonArray, true);
// [
// ['id' => 1, 'name' => 'John'],
// ['id' => 2, 'name' => 'Jane']
// ]
// Without recursion
$result = $objectify->json_mapper($jsonArray, false);
// [
// '{"id":1,"name":"John"}', // Not decoded
// '{"id":2,"name":"Jane"}'
// ]
// Non-JSON value returns unchanged
$result = $objectify->json_mapper('plain text');
// 'plain text'
json_mapper_norecurse()
Decode JSON strings without recursive processing (alias for json_mapper() with recursive = false).
public function json_mapper_norecurse($value): mixed
Decoded value without recursive array processing
Example Usage
$objectify = new Objectify();
$json = '{"name":"John","age":30}';
$result = $objectify->json_mapper_norecurse($json);
// ['name' => 'John', 'age' => 30]
// Arrays won't be recursively processed
$jsonArray = [
'{"id":1}',
'{"id":2}'
];
$result = $objectify->json_mapper_norecurse($jsonArray);
// ['{"id":1}', '{"id":2}'] // JSON strings remain as strings
json_to_array()
Convert JSON strings in an array to decoded arrays with optional recursive processing.
public function json_to_array($array, $recursive = true): array
Array to process. If not an array, it will be converted to a single-element array
Whether to recursively process nested elements
Array with JSON strings decoded to arrays
Example Usage
$objectify = new Objectify();
// Process array of JSON strings
$data = [
'{"id":1,"name":"Product A"}',
'{"id":2,"name":"Product B"}',
];
$result = $objectify->json_to_array($data);
// [
// ['id' => 1, 'name' => 'Product A'],
// ['id' => 2, 'name' => 'Product B']
// ]
// Non-array input is converted to array
$json = '{"name":"John"}';
$result = $objectify->json_to_array($json);
// [['name' => 'John']]
// Without recursion
$data = [
'{"id":1}',
'{"id":2}'
];
$result = $objectify->json_to_array($data, false);
// JSON strings won't be decoded
Use Cases
Processing API Responses
use Ronu\RestGenericClass\Core\Helpers\Objectify;
$objectify = new Objectify();
// API returns JSON string in database field
$users = DB::table('users')->get();
foreach ($users as $user) {
// metadata field contains JSON string
$user->metadata = $objectify->json_mapper($user->metadata);
}
// Now metadata is an array instead of JSON string
Batch Processing JSON Data
$objectify = new Objectify();
// Array of JSON strings from external source
$jsonStrings = [
'{"order_id":1,"total":99.99}',
'{"order_id":2,"total":149.99}',
'{"order_id":3,"total":79.99}',
];
$orders = $objectify->json_to_array($jsonStrings);
foreach ($orders as $order) {
echo "Order #{$order['order_id']}: ${$order['total']}\n";
}
// Order #1: $99.99
// Order #2: $149.99
// Order #3: $79.99
Handling Nested JSON
$objectify = new Objectify();
// Nested JSON strings
$data = [
'user' => '{"name":"John","email":"john@example.com"}',
'settings' => '{"theme":"dark","notifications":true}',
];
// Map all values
$decoded = array_map(
[$objectify, 'json_mapper'],
$data
);
// Result:
// [
// 'user' => ['name' => 'John', 'email' => 'john@example.com'],
// 'settings' => ['theme' => 'dark', 'notifications' => true]
// ]
Complete Example
use Ronu\RestGenericClass\Core\Helpers\Objectify;
class ProductController extends Controller
{
public function index()
{
$objectify = new Objectify();
// Get products with JSON attributes field
$products = DB::table('products')
->select('id', 'name', 'attributes')
->get();
// Decode JSON attributes for each product
$products = $products->map(function ($product) use ($objectify) {
$product->attributes = $objectify->json_mapper($product->attributes);
return $product;
});
return response()->json($products);
}
public function bulkImport(Request $request)
{
$objectify = new Objectify();
// Request contains array of JSON strings
$jsonData = $request->input('products');
// [
// '{"name":"Product A","price":19.99}',
// '{"name":"Product B","price":29.99}'
// ]
// Convert all to arrays
$products = $objectify->json_to_array($jsonData);
// Insert into database
foreach ($products as $product) {
Product::create($product);
}
return response()->json([
'message' => 'Products imported successfully',
'count' => count($products)
]);
}
}
Notes
The json_mapper() method will return the original value unchanged if:
- The value is not a string
- The string is not valid JSON
- JSON decoding fails
When using json_to_array(), if the input is not an array, it will be wrapped in an array first. This means a single JSON string will become an array containing the decoded data.
Use json_mapper_norecurse() when you have a mixed array where only top-level JSON strings should be decoded, and nested structures should remain unchanged.