refactor: consolidate CallQueuedClosure to support package

src/async-queue-closure-job/README.md

@@ -6,6 +6,8 @@
 
 The async queue closure job component for Hyperf. Execute closures as background jobs with full support for dependency injection, fluent configuration.
 
+> **Note**: Starting from v3.1.73, this package serves as a convenience wrapper around the `friendsofhyperf/support` package. The core implementation (`CallQueuedClosure` and related classes) has been moved to the support package to eliminate circular dependencies and improve package architecture.
+
 ## Installation
 
 ```shell
@@ -109,14 +111,39 @@ The main dispatch function that creates a closure job.
 - Closures with captured variables (`use`)
 - Closures with nullable parameters
 
-## Testing
+## Package Architecture
 
-Run tests:
+As of v3.1.73, this package has been refactored to improve the overall architecture:
 
-```shell
-composer test:unit -- tests/AsyncQueueClosureJob
+- **Core Implementation**: Moved to `friendsofhyperf/support` package
+  - `FriendsOfHyperf\Support\CallQueuedClosure`
+  - `FriendsOfHyperf\Support\Traits\ClosureParameterInjection`
+- **Convenience Layer**: This package now provides a namespace alias for easy migration
+  - `FriendsOfHyperf\AsyncQueueClosureJob\dispatch()` → delegates to support package
+
+### Why This Change?
+
+1. **Eliminates Circular Dependencies**: The support package previously depended on this package, creating a circular dependency
+2. **Single Source of Truth**: Core functionality now lives in one place
+3. **Simplified Dependency Tree**: Reduces maintenance overhead
+4. **Non-Breaking**: Existing code continues to work without changes
+
+### Migration Guide
+
+**No action required!** The namespace `FriendsOfHyperf\AsyncQueueClosureJob\dispatch()` continues to work as before. However, if you want to use the new location directly:
+
+```php
+// Old (still supported)
+use function FriendsOfHyperf\AsyncQueueClosureJob\dispatch;
+
+// New (recommended for new code)
+use function FriendsOfHyperf\Support\dispatch;
 ```
 
+## Testing
+
+Tests for the core functionality are now maintained in the support package.
+
 ## Contributing
 
 Contributions are welcome! Please feel free to submit a Pull Request.

src/async-queue-closure-job/composer.json

@@ -20,12 +20,7 @@
         "pull-request": "https://github.com/friendsofhyperf/components/pulls"
     },
     "require": {
-        "hyperf/async-queue": "~3.1.0",
-        "hyperf/conditionable": "~3.1.0",
-        "hyperf/context": "~3.1.0",
-        "hyperf/di": "~3.1.0",
-        "hyperf/support": "~3.1.72",
-        "laravel/serializable-closure": "^1.0 || ^2.0"
+        "hyperf/support": "~3.1.73"
     },
     "minimum-stability": "dev",
     "autoload": {

src/async-queue-closure-job/src/ConfigProvider.php

@@ -15,15 +15,6 @@ final class ConfigProvider
 {
     public function __invoke()
     {
-        return [
-            'dependencies' => [],
-            'annotations' => [
-                'scan' => [
-                    'paths' => [
-                        __DIR__,
-                    ],
-                ],
-            ],
-        ];
+        return [];
     }
 }

src/async-queue-closure-job/src/Functions.php

@@ -13,16 +13,19 @@
 
 use Closure;
 use FriendsOfHyperf\Support\Bus\PendingAsyncQueueDispatch;
+use FriendsOfHyperf\Support\CallQueuedClosure;
+
+use function FriendsOfHyperf\Support\dispatch as base_dispatch;
 
 /**
  * Dispatch a closure as an async queue job.
  *
+ * @deprecated since version 3.1.73, will be removed in version 3.2, use `FriendsOfHyperf\Support\dispatch` instead.
+ *
  * @param Closure $closure The closure to execute
  * @param-closure-this CallQueuedClosure $closure
  */
 function dispatch(Closure $closure): PendingAsyncQueueDispatch
 {
-    return new PendingAsyncQueueDispatch(
-        CallQueuedClosure::create($closure)
-    );
+    return base_dispatch($closure);
 }

src/helpers/src/Functions.php

@@ -17,9 +17,9 @@
 use Countable;
 use DateTimeZone;
 use Exception;
-use FriendsOfHyperf\AsyncQueueClosureJob\CallQueuedClosure;
 use FriendsOfHyperf\AsyncTask\Task as AsyncTask;
 use FriendsOfHyperf\AsyncTask\TaskInterface as AsyncTaskInterface;
+use FriendsOfHyperf\Support\CallQueuedClosure;
 use FriendsOfHyperf\Support\Environment;
 use Hyperf\Amqp\Message\ProducerMessageInterface;
 use Hyperf\Amqp\Producer;

src/support/README.md

@@ -4,16 +4,216 @@
 [![Total Downloads](https://img.shields.io/packagist/dt/friendsofhyperf/support.svg?style=flat-square)](https://packagist.org/packages/friendsofhyperf/support)
 [![GitHub license](https://img.shields.io/github/license/friendsofhyperf/support)](https://github.com/friendsofhyperf/support)
 
-Another support component for Hyperf.
+A comprehensive support component for Hyperf providing essential utilities, helpers, and base classes.
 
-## Installation
+## Features
+
+- 🎯 **Fluent Dispatch API** - Elegant job dispatch with support for async queue, AMQP, and Kafka
+- 🔄 **Closure Jobs** - Execute closures as background jobs with dependency injection
+- 🛠️ **Helper Functions** - Collection of useful helper functions
+- 📦 **Bus System** - Pending dispatch classes for various message systems
+- 🧩 **Traits & Utilities** - Reusable traits and utility classes
 
-- Installation
+## Installation
 
 ```shell
 composer require friendsofhyperf/support
 ```
 
+## Usage
+
+### Dispatch Helper Function
+
+The `dispatch()` helper function provides a fluent API for dispatching jobs to different systems:
+
+#### Async Queue (Closure Jobs)
+
+```php
+use function FriendsOfHyperf\Support\dispatch;
+
+// Simple closure dispatch to async queue
+dispatch(function () {
+    // Your job logic here
+    logger()->info('Job executed!');
+});
+
+// With configuration
+dispatch(function () {
+    // Your job logic here
+})
+    ->onConnection('high-priority')
+    ->delay(60) // Execute after 60 seconds
+    ->setMaxAttempts(5);
+
+// With dependency injection
+dispatch(function (UserService $userService, LoggerInterface $logger) {
+    $users = $userService->getActiveUsers();
+    $logger->info('Processing ' . count($users) . ' users');
+});
+```
+
+#### AMQP Producer Messages
+
+```php
+use Hyperf\Amqp\Message\ProducerMessageInterface;
+use function FriendsOfHyperf\Support\dispatch;
+
+// Dispatch AMQP message
+dispatch($amqpMessage)
+    ->setPool('default')
+    ->setExchange('my.exchange')
+    ->setRoutingKey('my.routing.key')
+    ->setTimeout(10)
+    ->setConfirm(true);
+```
+
+#### Kafka Producer Messages
+
+```php
+use Hyperf\Kafka\Producer\ProduceMessage;
+use function FriendsOfHyperf\Support\dispatch;
+
+// Dispatch Kafka message
+dispatch($kafkaMessage)
+    ->setPool('default');
+```
+
+### CallQueuedClosure
+
+The `CallQueuedClosure` class allows you to execute closures as async queue jobs:
+
+```php
+use FriendsOfHyperf\Support\CallQueuedClosure;
+
+// Create a closure job
+$job = CallQueuedClosure::create(function () {
+    // Your job logic
+    return 'Job completed!';
+});
+
+// Configure max attempts
+$job->setMaxAttempts(3);
+
+// The job can be pushed to queue manually or via dispatch()
+```
+
+### Pending Dispatch Classes
+
+#### PendingAsyncQueueDispatch
+
+Fluent API for async queue job dispatch:
+
+```php
+use FriendsOfHyperf\Support\Bus\PendingAsyncQueueDispatch;
+
+$pending = new PendingAsyncQueueDispatch($job);
+$pending
+    ->onConnection('default')
+    ->delay(30)
+    ->when($condition, function ($dispatch) {
+        $dispatch->onConnection('special');
+    })
+    ->unless($otherCondition, function ($dispatch) {
+        $dispatch->delay(60);
+    });
+// Job is dispatched when object is destroyed
+```
+
+#### PendingAmqpProducerMessageDispatch
+
+Fluent API for AMQP message dispatch:
+
+```php
+use FriendsOfHyperf\Support\Bus\PendingAmqpProducerMessageDispatch;
+
+$pending = new PendingAmqpProducerMessageDispatch($message);
+$pending
+    ->setPool('default')
+    ->setExchange('my.exchange')
+    ->setRoutingKey('my.routing.key')
+    ->setTimeout(5)
+    ->setConfirm(true);
+// Message is sent when object is destroyed
+```
+
+#### PendingKafkaProducerMessageDispatch
+
+Fluent API for Kafka message dispatch:
+
+```php
+use FriendsOfHyperf\Support\Bus\PendingKafkaProducerMessageDispatch;
+
+$pending = new PendingKafkaProducerMessageDispatch($message);
+$pending->setPool('default');
+// Message is sent when object is destroyed
+```
+
+### Conditional Execution
+
+All pending dispatch classes support conditional execution:
+
+```php
+use function FriendsOfHyperf\Support\dispatch;
+
+dispatch($job)
+    ->when($shouldUseHighPriority, function ($dispatch) {
+        $dispatch->onConnection('high-priority');
+    })
+    ->unless($isTestMode, function ($dispatch) {
+        $dispatch->delay(10);
+    });
+```
+
+## API Reference
+
+### dispatch($job)
+
+Creates a pending dispatch instance based on the job type:
+
+- `Closure` → `PendingAsyncQueueDispatch` with `CallQueuedClosure`
+- `ProducerMessageInterface` → `PendingAmqpProducerMessageDispatch`
+- `ProduceMessage` → `PendingKafkaProducerMessageDispatch`
+- Other objects → `PendingAsyncQueueDispatch`
+
+### PendingAsyncQueueDispatch Methods
+
+- `onConnection(string $connection): static` - Set queue connection
+- `delay(int $delay): static` - Delay job execution (seconds)
+- `setMaxAttempts(int $attempts): static` - Set max retry attempts
+- `when(mixed $condition, callable $callback): static` - Conditional execution
+- `unless(mixed $condition, callable $callback): static` - Inverse conditional execution
+
+### PendingAmqpProducerMessageDispatch Methods
+
+- `setPool(string $pool): static` - Set AMQP pool name
+- `setExchange(string $exchange): static` - Set exchange name
+- `setRoutingKey(array|string $routingKey): static` - Set routing key(s)
+- `setTimeout(int $timeout): static` - Set timeout (seconds)
+- `setConfirm(bool $confirm): static` - Enable/disable confirm mode
+- `when(mixed $condition, callable $callback): static` - Conditional execution
+- `unless(mixed $condition, callable $callback): static` - Inverse conditional execution
+
+### PendingKafkaProducerMessageDispatch Methods
+
+- `setPool(string $pool): static` - Set Kafka pool name
+- `when(mixed $condition, callable $callback): static` - Conditional execution
+- `unless(mixed $condition, callable $callback): static` - Inverse conditional execution
+
+### CallQueuedClosure
+
+- `create(Closure $closure): static` - Create a new closure job
+- `setMaxAttempts(int $attempts): void` - Set max retry attempts
+- `handle(): mixed` - Execute the closure (called by queue worker)
+
+## Architecture Notes
+
+As of v3.1.73, this package includes the core async queue closure functionality:
+
+- Previously in `friendsofhyperf/async-queue-closure-job`
+- Moved here to eliminate circular dependencies
+- The `async-queue-closure-job` package now depends on this package
+- All functionality remains backward compatible
+
 ## Contact
 
 - [Twitter](https://twitter.com/huangdijia)

src/support/composer.json

@@ -20,7 +20,6 @@
         "pull-request": "https://github.com/friendsofhyperf/components/pulls"
     },
     "require": {
-        "friendsofhyperf/async-queue-closure-job": "~3.1.0",
         "hyperf/collection": "~3.1.0",
         "hyperf/context": "~3.1.0",
         "hyperf/di": "~3.1.0",
@@ -29,6 +28,7 @@
         "hyperf/stringable": "~3.1.0",
         "hyperf/support": "~3.1.0",
         "hyperf/tappable": "~3.1.0",
+        "laravel/serializable-closure": "^1.0 || ^2.0",
         "nesbot/carbon": "^2.0 || ^3.0",
         "symfony/polyfill-php85": "^1.33"
     },

src/support/src/AsyncQueue/ClosureJob.php

@@ -12,12 +12,13 @@
 namespace FriendsOfHyperf\Support\AsyncQueue;
 
 use Closure;
+use FriendsOfHyperf\Support\CallQueuedClosure;
 use Laravel\SerializableClosure\SerializableClosure;
 
 /**
  * @deprecated since v3.2, will be removed in v3.2, use `FriendsOfHyperf\AsyncQueueClosureJob\ClosureJob` instead.
  */
-class ClosureJob extends \FriendsOfHyperf\AsyncQueueClosureJob\CallQueuedClosure
+class ClosureJob extends CallQueuedClosure
 {
     public function __construct(Closure $closure, int $maxAttempts = 0)
     {