@ethlete/query 6.0.0-next.53 → 6.0.0-next.54

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @ethlete/query
 
+## 6.0.0-next.54
+
+### Patch Changes
+
+- Stop a legacy `InfinityQuery` from aborting a non-cacheable page (such as a POST) that is still loading when it is reset or destroyed; the page now finishes and is destroyed once it settles.
+- A legacy query container or collection destroyed while its mutation is in flight now lets the request finish instead of cancelling it.
+- An interop mutation whose prepare injector is destroyed while its request is in flight now finishes before it is destroyed, as it did in v2.
+- Destroying the owner of a legacy mutation that waits to settle after its container let go no longer throws NG0205.
+- A mutation whose `withArgs` source returns `null` while its request is in flight is no longer aborted; it finishes and the query parks once it has settled.
+
 ## 6.0.0-next.53
 
 ### Major Changes

package/fesm2022/ethlete-query.mjs

@@ -1186,7 +1186,7 @@ const setupQueryDependencies = (options) => {
     const clientToken = options.client.token;
     const dependencies = {
         destroyRef: undefined, // Will be set after injector creation
-        scopeDestroyRef: hostInjector.get(DestroyRef),
+        scopeDestroyRef: options.queryConfig?.scopeDestroyRef ?? hostInjector.get(DestroyRef),
         client: hostInjector.get(clientToken),
         injector: undefined, // Will be set after injector creation
         ngErrorHandler: hostInjector.get(ErrorHandler),
@@ -1457,7 +1457,8 @@ const createQueryFeature = (config) => {
  * The arguments are read within a computed function, so you can use reactive values.
  *
  * Return `null` to park the query: it is reset (`response()` and `executionState()` become `null`),
- * and polling and auto refresh pause until args are set again.
+ * and polling and auto refresh pause until args are set again. A mutation that is still in flight
+ * finishes first and the query parks once it has settled.
  *
  * Changing arguments will automatically trigger a new execution of the query if it is eligible for auto execution (e.g. a GET request).
  */
@@ -1474,6 +1475,8 @@ const withArgs = (args) => {
             nestedEffect(() => {
                 const currArgsNow = context.state.args();
                 if (currArgsNow === null) {
+                    if (!context.flags.shouldAutoExecuteMethod && context.state.loading() !== null)
+                        return;
                     untracked(() => {
                         if (context.state.subtle.request() !== null || context.state.loading() !== null)
                             context.execute.reset();
@@ -2495,7 +2498,10 @@ const trackRefreshedExecutions = (options) => {
 };
 const createQueryObject = (options) => {
     const { state, execute, deps } = options;
-    const destroy = () => deps.injector.destroy();
+    const destroy = () => {
+        if (!deps.injector.destroyed)
+            deps.injector.destroy();
+    };
     const setResponse = (response) => state.response.set(response);
     const setLoading = (loading) => state.loading.set(loading);
     const setError = (error) => state.error.set(error);
@@ -10976,7 +10982,7 @@ const withQueryDevtoolsOverridePersistence = (id, recorder) => {
 
 // Generated from package.json by tools/scripts/generate-version.js - do not edit.
 /** The version of `@ethlete/query` this build was cut from. */
-const QUERY_VERSION = '6.0.0-next.53';
+const QUERY_VERSION = '6.0.0-next.54';
 
 /** How deep a schema is expanded before a nested branch is given up on. */
 const MAX_DEPTH = 12;
@@ -13059,6 +13065,15 @@ const request = (config) => {
     });
 };
 
+/**
+ * Destroying a legacy query tears down the underlying query's injector, which cancels its request - so
+ * a superseded or released query that was not aborted (a mutation the server may already have accepted)
+ * is torn down only once it has settled. `state$` completes with the query, so this ends either way.
+ */
+const destroyOnceSettled = (query) => {
+    query.state$.pipe(takeUntilResponse()).subscribe({ complete: () => query.destroy() });
+};
+
 let nextQueryContainerOwnerId = 0;
 const queryContainerOwnerIds = /* @__PURE__ */ new WeakMap();
 const queryContainerOwnerId = (injector) => {
@@ -13070,14 +13085,6 @@ const queryContainerOwnerId = (injector) => {
     queryContainerOwnerIds.set(injector, id);
     return id;
 };
-/**
- * Destroying a legacy query tears down the underlying query's injector, which cancels its request - so
- * a superseded query that was not aborted (a mutation the server may already have accepted) is torn
- * down only once it has settled. `state$` completes with the query, so this ends either way.
- */
-const destroyOnceSettled = (query) => {
-    query.state$.pipe(takeUntilResponse()).subscribe({ complete: () => query.destroy() });
-};
 /**
  * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
  */
@@ -13153,7 +13160,14 @@ const addQueryContainerHandling = (obs, valueFn, config) => {
             if ((q?.canBeCached && abortOnDestroy === undefined) || abortOnDestroy) {
                 q?.abort();
             }
-            q?.destroy?.();
+            const legacyQuery = q;
+            if (!legacyQuery?.destroy)
+                return;
+            if (isQueryStateLoading(q?.rawState)) {
+                destroyOnceSettled(legacyQuery);
+                return;
+            }
+            legacyQuery.destroy();
         };
         if (isQuery(query)) {
             handleQuery(query);
@@ -14204,6 +14218,35 @@ const isInjectorUsable = (injector) => {
         return false;
     }
 };
+/**
+ * The scope ends when its owner dies with no request in flight, when that request settles, or when the
+ * owner's nearest environment injector dies - a destroyed injector does not destroy the environment
+ * injectors made with `createEnvironmentInjector` below it.
+ */
+const createSettleScope = (owner) => {
+    const anchor = owner.get(EnvironmentInjector);
+    const scope = createEnvironmentInjector([], anchor);
+    const end = () => {
+        if (!scope.destroyed)
+            scope.destroy();
+    };
+    const bind = (query, queryInjector) => {
+        const stopOnAnchorDestroy = anchor.get(DestroyRef).onDestroy(end);
+        const stopOnOwnerDestroy = owner.get(DestroyRef).onDestroy(() => {
+            if (isQueryStateLoading(untracked(() => query.rawState))) {
+                query.state$.pipe(takeUntilResponse()).subscribe({ complete: end });
+                return;
+            }
+            end();
+        });
+        queryInjector.get(DestroyRef).onDestroy(() => {
+            stopOnAnchorDestroy();
+            stopOnOwnerDestroy();
+            end();
+        });
+    };
+    return { destroyRef: scope.get(DestroyRef), bind };
+};
 /**
  * Angular's NG0203, thrown by `inject()` outside an injection context. Matched on the code rather than
  * the message: production builds strip the message, and NG0205 ("Injector has already been destroyed")
@@ -14278,14 +14321,17 @@ class LegacyQueryCreator {
             }
             return runInInjectionContext(injector, () => {
                 return untracked(() => {
+                    const settleScope = this.canBeCached ? null : createSettleScope(injector);
                     const newQuery = this.options.creator({
                         onlyManualExecution: true,
                         injector,
+                        ...(settleScope ? { scopeDestroyRef: settleScope.destroyRef } : {}),
                         silenceMissingWithArgsFeatureError: true,
                         // `LegacyQuery.execute()` forwards v2's `skipCache` as `allowCache` for every method, cacheable or not.
                         silenceUncacheableAllowCacheError: true,
                     });
                     const legacyQuery = new LegacyQuery(newQuery, queryArgs, this.options.entity, false, this.canBeCached);
+                    settleScope?.bind(legacyQuery, newQuery.subtle.injector);
                     if (args?.config?.destroyOnResponse) {
                         // Owned by the query's own injector, not the caller's. Call sites are told to pass an injector
                         // that outlives them, so they hand over a root or environment one - and an effect that only
@@ -15490,9 +15536,16 @@ class InfinityQuery {
     destroyQueries() {
         for (const query of this.queries$.value) {
             query.stopPolling();
-            query.abort();
-            if ('destroy' in query && typeof query.destroy === 'function')
+            if (query.canBeCached)
+                query.abort();
+            if (!('destroy' in query) || typeof query.destroy !== 'function')
+                continue;
+            if (!query.canBeCached && isQueryStateLoading(query.rawState)) {
+                destroyOnceSettled(query);
+            }
+            else {
                 query.destroy();
+            }
         }
     }
     prepareArgs(config, page) {