Update storage credentials, through relationships and scheduler interrupts

src/console/src/Commands/ScheduleInterruptCommand.php

@@ -15,9 +15,7 @@ class ScheduleInterruptCommand extends Command
     /**
      * The console signature name.
      */
-    protected ?string $signature = 'schedule:interrupt
-        {--minutes=1 : TTL in minutes for the interrupt signal (minimum 1)}
-    ';
+    protected ?string $signature = 'schedule:interrupt';
 
     /**
      * The console command description.
@@ -38,19 +36,7 @@ public function __construct(
      */
     public function handle(): int
     {
-        $minutes = filter_var($this->option('minutes'), FILTER_VALIDATE_INT);
-
-        if ($minutes === false || $minutes < 1) {
-            $this->components->error('The --minutes option must be an integer of at least 1.');
-
-            return self::FAILURE;
-        }
-
-        $this->cache->put(
-            'hypervel:schedule:interrupt',
-            true,
-            Date::now()->addMinutes($minutes)
-        );
+        $this->cache->forever('hypervel:schedule:interrupt', Date::now()->getTimestampMs());
 
         $this->components->info('Broadcasting schedule interrupt signal.');
 

src/console/src/Commands/ScheduleRunCommand.php

@@ -90,17 +90,17 @@ class ScheduleRunCommand extends Command
     protected bool $eventsRan = false;
 
     /**
-     * Check if scheduler should stop.
+     * Whether this schedule run has been interrupted.
      */
-    protected bool $shouldStop = false;
+    protected bool $interrupted = false;
 
     /**
      * Whether a termination signal has requested shutdown.
      */
     protected bool $shouldQuit = false;
 
     /**
-     * Last time the stopped state was checked.
+     * Last time the interruption state was checked.
      */
     protected ?CarbonInterface $lastChecked = null;
 
@@ -147,7 +147,7 @@ public function handle(
         Cache $cache,
         ExceptionHandler $handler,
     ): void {
-        $this->shouldQuit = false;
+        $this->startedAt = Date::now();
 
         $this->schedule = $schedule;
         $this->dispatcher = $dispatcher;
@@ -168,15 +168,13 @@ public function handle(
         $this->listenForSignals();
 
         try {
-            $this->clearShouldStop();
-
             $noEventsAlerted = false;
-            while (! $this->shouldQuit && ! $this->shouldStop()) {
-                $startedAt = Date::now();
+            while (! $this->shouldQuit && ! $this->shouldInterrupt()) {
+                $now = Date::now();
 
                 $this->runEvents(
-                    $this->schedule->dueEventsAt($this->hypervel, $startedAt),
-                    $startedAt
+                    $this->schedule->dueEventsAt($this->hypervel, $now),
+                    $now
                 );
 
                 if (! $this->eventsRan && ! $noEventsAlerted && ! $this->option('whisper')) {
@@ -215,14 +213,8 @@ protected function stop(): void
      */
     protected function runOnce(): void
     {
-        $this->startedAt = Date::now();
-
         $events = $this->schedule->dueEventsAt($this->hypervel, $this->startedAt);
 
-        if ($events->contains->isRepeatable()) {
-            $this->clearShouldStop();
-        }
-
         // The finite --once path runs inside Waiter; signal-wait coroutines keep
         // that scheduler coroutine alive, so mutex signal cleanup is long-run only.
         (new Waiter(-1))->wait(function () use ($events) {
@@ -250,7 +242,7 @@ protected function repeatEvents(Collection $events): void
             $paused = $this->isPaused();
 
             foreach ($events as $event) {
-                if ($this->shouldStop()) {
+                if ($this->shouldInterrupt()) {
                     return;
                 }
 
@@ -586,7 +578,7 @@ protected function isPaused(): bool
     /**
      * Determine if the schedule run should be interrupted.
      */
-    protected function shouldStop(): bool
+    protected function shouldInterrupt(): bool
     {
         if (! Schedule::$interruptible) {
             return false;
@@ -596,23 +588,14 @@ protected function shouldStop(): bool
             $this->lastChecked = Date::now();
         }
 
-        if ($this->shouldStop || abs($this->lastChecked->diffInSeconds()) < 1) {
-            return $this->shouldStop;
+        // The loop and repeating events check more often; avoid a cache round trip on every check.
+        if ($this->interrupted || abs($this->lastChecked->diffInSeconds()) < 1) {
+            return $this->interrupted;
         }
 
         $this->lastChecked = Date::now();
 
-        return $this->shouldStop = (bool) $this->cache->get('hypervel:schedule:interrupt', false);
-    }
-
-    /**
-     * Clear the interrupt cache.
-     */
-    protected function clearShouldStop(): void
-    {
-        $this->cache->forget('hypervel:schedule:interrupt');
-
-        $this->shouldStop = false;
+        return $this->interrupted = $this->schedule->hasBeenInterruptedSince($this->startedAt);
     }
 
     /**

src/console/src/Scheduling/Schedule.php

@@ -483,6 +483,20 @@ public static function withoutInterruptionPolling(): void
         static::$interruptible = false;
     }
 
+    /**
+     * Determine if the schedule has been interrupted since the given time.
+     */
+    public function hasBeenInterruptedSince(DateTimeInterface $time): bool
+    {
+        if (! static::$interruptible) {
+            return false;
+        }
+
+        $interruptedAt = Container::getInstance()->make(Cache::class)->get('hypervel:schedule:interrupt');
+
+        return is_numeric($interruptedAt) && (int) $interruptedAt >= Date::instance($time)->getTimestampMs();
+    }
+
     /**
      * Flush all static state.
      */

src/database/README.md

@@ -28,6 +28,6 @@ Documentation: https://hypervel.org/docs/database
 - Eloquent expression plucks use `Query\Builder::pluckWithColumn()` to retain the returned field name for casts and accessors. Custom query builders overriding `pluck()` must also override `pluckWithColumn()` to customize this path. String-based Eloquent plucks still call `pluck()`.
 - Eloquent's protected `refreshSavedAttributes()` method receives the raw attribute values each write stored, so configured attributes are refreshed from the row that write changed. Models that override this method must accept the `array $attributes` argument.
 - Eloquent `updateFrom()` maintains the model's `updated_at` timestamp, like `update()`. Laravel forwards this method without adding a timestamp.
-- `BelongsToMany` records pivot filters in an ordered `$pivotConstraints` list instead of Laravel's `$pivotWheres`, `$pivotWhereIns`, and `$pivotWhereNulls` properties. Relationship extensions should use the `wherePivot*` methods instead of accessing those arrays.
+- `BelongsToMany` records pivot filters in an ordered `$pivotConstraints` list instead of Laravel's `$pivotWheres`, `$pivotWhereIns`, `$pivotWhereNulls`, and `$pivotWhereBetweens` properties. Relationship extensions should use the `wherePivot*` methods instead of accessing those arrays.
 
 Ported from: https://github.com/laravel/framework

src/database/src/Eloquent/Concerns/HasRelationships.php

@@ -476,18 +476,14 @@ protected function guessBelongsToRelation(): string
      * Create a pending has-many-through or has-one-through relationship.
      *
      * @template TIntermediateModel of Model
+     * @template TLocalRelationship of HasOneOrMany<TIntermediateModel, $this, *>
      *
-     * @param HasMany<TIntermediateModel, covariant $this>|HasOne<TIntermediateModel, covariant $this>|string $relationship
+     * @param string|TLocalRelationship $relationship
      * @return (
      *     $relationship is string
      *     ? PendingHasThroughRelationship<Model, $this, HasOneOrMany<Model, $this, *>>
-     *     : (
-     *          $relationship is HasMany<TIntermediateModel, $this>
-     *          ? PendingHasThroughRelationship<TIntermediateModel, $this, HasMany<TIntermediateModel, $this>>
-     *          : PendingHasThroughRelationship<TIntermediateModel, $this, HasOne<TIntermediateModel, $this>>
-     *     )
+     *     : PendingHasThroughRelationship<TIntermediateModel, $this, TLocalRelationship>
      * )
-     * @phpstan-ignore conditionalType.alwaysFalse (template covariance limitation with conditional return types)
      */
     public function through(string|HasOneOrMany $relationship): PendingHasThroughRelationship
     {

src/database/src/Eloquent/Model.php

@@ -2338,6 +2338,7 @@ public function replicate(?array $except = null): static
             $this->getCreatedAtColumn(),
             $this->getUpdatedAtColumn(),
             ...$this->uniqueIds(),
+            ...$this->refreshes,
             'hypervel_through_key',
         ]));
 

src/database/src/Eloquent/PendingHasThroughRelationship.php

@@ -10,6 +10,7 @@
 use Hypervel\Database\Eloquent\Relations\HasOne;
 use Hypervel\Database\Eloquent\Relations\HasOneOrMany;
 use Hypervel\Database\Eloquent\Relations\HasOneThrough;
+use Hypervel\Database\Eloquent\Relations\MorphMany;
 use Hypervel\Database\Eloquent\Relations\MorphOneOrMany;
 use Hypervel\Support\Str;
 use Hypervel\Support\Stringable;
@@ -52,30 +53,31 @@ public function __construct(Model $rootModel, HasOneOrMany $localRelationship)
      *
      * @template TRelatedModel of Model
      *
-     * @param (callable(TIntermediateModel): (HasMany<TRelatedModel, TIntermediateModel>|HasOne<TRelatedModel, TIntermediateModel>|MorphOneOrMany<TRelatedModel, TIntermediateModel, *>))|string $callback
+     * @param (callable(TIntermediateModel): (HasMany<TRelatedModel, TIntermediateModel>|HasOne<TRelatedModel, TIntermediateModel>|MorphMany<TRelatedModel, TIntermediateModel>|MorphOneOrMany<TRelatedModel, TIntermediateModel, *>))|string $callback
      * @return (
      *     $callback is string
      *     ? HasManyThrough<Model, TIntermediateModel, TDeclaringModel>|HasOneThrough<Model, TIntermediateModel, TDeclaringModel>
      *     : (
-     *         TLocalRelationship is HasMany<TIntermediateModel, TDeclaringModel>
+     *         TLocalRelationship is HasMany<TIntermediateModel, TDeclaringModel>|MorphMany<TIntermediateModel, TDeclaringModel>
      *         ? HasManyThrough<TRelatedModel, TIntermediateModel, TDeclaringModel>
      *         : (
-     *              $callback is callable(TIntermediateModel): HasMany<TRelatedModel, TIntermediateModel>
+     *              $callback is callable(TIntermediateModel): (HasMany<TRelatedModel, TIntermediateModel>|MorphMany<TRelatedModel, TIntermediateModel>)
      *              ? HasManyThrough<TRelatedModel, TIntermediateModel, TDeclaringModel>
      *              : HasOneThrough<TRelatedModel, TIntermediateModel, TDeclaringModel>
      *         )
      *     )
      * )
      */
-    public function has(callable|string $callback): mixed
+    public function has(callable|string $callback): HasManyThrough|HasOneThrough
     {
         if (is_string($callback)) {
             $callback = fn () => $this->localRelationship->getRelated()->{$callback}();
         }
 
         $distantRelation = $callback($this->localRelationship->getRelated());
 
-        if ($distantRelation instanceof HasMany || $this->localRelationship instanceof HasMany) {
+        if ($distantRelation instanceof HasMany || $distantRelation instanceof MorphMany
+            || $this->localRelationship instanceof HasMany || $this->localRelationship instanceof MorphMany) {
             $returnedRelation = $this->rootModel->hasManyThrough(
                 $distantRelation->getRelatedClass(),
                 $this->localRelationship->getRelatedClass(),
@@ -96,7 +98,11 @@ public function has(callable|string $callback): mixed
         }
 
         if ($this->localRelationship instanceof MorphOneOrMany) {
-            $returnedRelation->where($this->localRelationship->getQualifiedMorphType(), $this->localRelationship->getMorphClass());
+            $returnedRelation->whereMorphClass($this->localRelationship->getQualifiedMorphType(), $this->localRelationship->getMorphClass());
+        }
+
+        if ($distantRelation instanceof MorphOneOrMany) {
+            $returnedRelation->whereMorphClass($distantRelation->getQualifiedMorphType(), $distantRelation->getMorphClass());
         }
 
         return $returnedRelation;

src/database/src/Eloquent/Relations/HasManyThrough.php

@@ -27,7 +27,7 @@ class HasManyThrough extends HasOneOrManyThrough
      */
     public function one(): HasOneThrough
     {
-        return HasOneThrough::noConstraints(fn () => new HasOneThrough(
+        $relation = HasOneThrough::noConstraints(fn () => new HasOneThrough(
             tap($this->getQuery(), fn (Builder $query) => $query->getQuery()->joins = []),
             $this->farParent,
             $this->throughParent,
@@ -36,6 +36,10 @@ public function one(): HasOneThrough
             $this->getLocalKeyName(),
             $this->getSecondLocalKeyName(),
         ));
+
+        $relation->morphConstraints = $this->morphConstraints;
+
+        return $relation;
     }
 
     public function initRelation(array $models, string $relation): array

src/database/src/Eloquent/Relations/HasOneOrManyThrough.php

@@ -70,6 +70,13 @@ abstract class HasOneOrManyThrough extends Relation
      */
     protected string $secondLocalKey;
 
+    /**
+     * Morph identities that also constrain one-of-many subqueries.
+     *
+     * @var array<string, string>
+     */
+    protected array $morphConstraints = [];
+
     /**
      * Create a new has many through relationship instance.
      *
@@ -105,6 +112,19 @@ public function addConstraints(): void
         }
     }
 
+    /**
+     * Constrain the relationship to records of the given morph class.
+     *
+     * @return $this
+     */
+    public function whereMorphClass(string $column, string $morphClass): static
+    {
+        $this->morphConstraints[$column] = $morphClass;
+        $this->query->where($column, $morphClass);
+
+        return $this;
+    }
+
     /**
      * Set the join clause on the query.
      *

src/database/src/Eloquent/Relations/HasOneThrough.php

@@ -82,6 +82,10 @@ public function addOneOfManySubQueryConstraints(Builder $query, ?string $column
     {
         $query->addSelect([$this->getQualifiedFirstKeyName()]);
 
+        foreach ($this->morphConstraints as $morphColumn => $morphClass) {
+            $query->where($morphColumn, $morphClass);
+        }
+
         // We need to join subqueries that aren't the inner-most subquery which is joined in the CanBeOneOfMany::ofMany method...
         if ($this->getOneOfManySubQuery() !== null) {
             // @phpstan-ignore argument.type (Builder param typed without template in inherited interface)