@ethlete/query 5.25.1 → 5.26.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @ethlete/query
 
+## 5.26.0
+
+### Minor Changes
+
+- [`ee8928e`](https://github.com/ethlete-io/ethdk/commit/ee8928ecf262690698de4a19211d6a601f66fa27) Thanks [@TomTomB](https://github.com/TomTomB)! - Make route and query primary params instead of object properties
+
 ## 5.25.1
 
 ### Patch Changes

package/fesm2022/ethlete-query.mjs

@@ -3339,13 +3339,14 @@ const shouldRetryRequest = (options) => {
     return { retry: false };
 };
 const getQueryFeatureUsage = (options) => {
-    const { creator, features, queryConfig } = options;
+    const { creator, features, queryConfig, creatorInternals } = options;
     const hasWithArgsFeature = features.some((f) => f.type == "withArgs" /* QueryFeatureType.WithArgs */);
     const shouldAutoExecuteMethod = isCreateGqlQueryOptions(options)
         ? shouldAutoExecuteGqlQuery(options.creatorInternals.method)
         : shouldAutoExecuteQuery(options.creatorInternals.method);
     const shouldAutoExecute = shouldAutoExecuteMethod && !queryConfig.onlyManualExecution;
-    const hasRouteFunction = typeof creator.route === 'function';
+    const hasRouteFunction = typeof creatorInternals.route === 'function' ||
+        typeof creator.route === 'function';
     if (hasRouteFunction && !hasWithArgsFeature) {
         throw withArgsQueryFeatureMissingButRouteIsFunction();
     }
@@ -4093,15 +4094,10 @@ const queryExecute = (options) => {
     const { executeOptions, args, executeState, options: runQueryOptions, internalOptions: internalRunQueryOptions, transformResponse, } = options;
     const { deps, state, creator, creatorInternals, queryConfig } = executeOptions;
     const { key, request } = deps.client.repository.request({
-        route: creator.route,
+        route: creatorInternals.route,
         method: creatorInternals.method,
         args,
-        clientOptions: {
-            reportProgress: creator.reportProgress,
-            withCredentials: creator.withCredentials,
-            transferCache: creator.transferCache,
-            responseType: creator.responseType,
-        },
+        clientOptions: creator,
         destroyRef: deps.destroyRef,
         key: queryConfig.key,
         previousKey: executeState.previousKey(),
@@ -4421,43 +4417,43 @@ const createSecureQueryCreator = (options, internals) => {
 
 /** A query creator that creates a GET query */
 const createGetQuery = (client) => {
-    return (creatorOptions) => createQueryCreator(creatorOptions, { method: 'GET', client });
+    return (route, creatorOptions) => createQueryCreator(creatorOptions, { method: 'GET', client, route });
 };
 /** A query creator that creates a secure GET query (requires authentication) */
 const createSecureGetQuery = (client, authProvider) => {
-    return (creatorOptions) => createSecureQueryCreator(creatorOptions, { method: 'GET', client, authProvider });
+    return (route, creatorOptions) => createSecureQueryCreator(creatorOptions, { method: 'GET', client, authProvider, route });
 };
 /** A query creator that creates a POST query */
 const createPostQuery = (client) => {
-    return (creatorOptions) => createQueryCreator(creatorOptions, { method: 'POST', client });
+    return (route, creatorOptions) => createQueryCreator(creatorOptions, { method: 'POST', client, route });
 };
 /** A query creator that creates a secure POST query (requires authentication) */
 const createSecurePostQuery = (client, authProvider) => {
-    return (creatorOptions) => createSecureQueryCreator(creatorOptions, { method: 'POST', client, authProvider });
+    return (route, creatorOptions) => createSecureQueryCreator(creatorOptions, { method: 'POST', client, authProvider, route });
 };
 /** A query creator that creates a PUT query */
 const createPutQuery = (client) => {
-    return (creatorOptions) => createQueryCreator(creatorOptions, { method: 'PUT', client });
+    return (route, creatorOptions) => createQueryCreator(creatorOptions, { method: 'PUT', client, route });
 };
 /** A query creator that creates a secure PUT query (requires authentication) */
 const createSecurePutQuery = (client, authProvider) => {
-    return (creatorOptions) => createSecureQueryCreator(creatorOptions, { method: 'PUT', client, authProvider });
+    return (route, creatorOptions) => createSecureQueryCreator(creatorOptions, { method: 'PUT', client, authProvider, route });
 };
 /** A query creator that creates a DELETE query */
 const createDeleteQuery = (client) => {
-    return (creatorOptions) => createQueryCreator(creatorOptions, { method: 'DELETE', client });
+    return (route, creatorOptions) => createQueryCreator(creatorOptions, { method: 'DELETE', client, route });
 };
 /** A query creator that creates a secure DELETE query (requires authentication) */
 const createSecureDeleteQuery = (client, authProvider) => {
-    return (creatorOptions) => createSecureQueryCreator(creatorOptions, { method: 'DELETE', client, authProvider });
+    return (route, creatorOptions) => createSecureQueryCreator(creatorOptions, { method: 'DELETE', client, authProvider, route });
 };
 /** A query creator that creates a PATCH query */
 const createPatchQuery = (client) => {
-    return (creatorOptions) => createQueryCreator(creatorOptions, { method: 'PATCH', client });
+    return (route, creatorOptions) => createQueryCreator(creatorOptions, { method: 'PATCH', client, route });
 };
 /** A query creator that creates a secure PATCH query (requires authentication) */
 const createSecurePatchQuery = (client, authProvider) => {
-    return (creatorOptions) => createSecureQueryCreator(creatorOptions, { method: 'PATCH', client, authProvider });
+    return (route, creatorOptions) => createSecureQueryCreator(creatorOptions, { method: 'PATCH', client, authProvider, route });
 };
 
 const createGqlExecuteFn = (executeOptions) => {
@@ -4467,7 +4463,7 @@ const createGqlExecuteFn = (executeOptions) => {
         const { args = executeOptions.state.args(), options } = executeArgs ?? {};
         cleanupPreviousExecute({ executeOptions, executeState });
         // TODO: This should get cleaned up
-        const tpl = executeOptions.creator.query;
+        const tpl = executeOptions.creatorInternals.query;
         const query = transformGql(tpl);
         let gqlParams = query(args?.variables);
         if (args?.queryParams && executeOptions.creatorInternals.transport === 'GET') {
@@ -4481,12 +4477,11 @@ const createGqlExecuteFn = (executeOptions) => {
             computedArgs.body = gqlParams;
         }
         const normalizedOpts = {
-            creator: {
-                route: (executeOptions.creator.route ?? ''),
-            },
+            creator: executeOptions.creator ?? {},
             creatorInternals: {
                 client: executeOptions.creatorInternals.client,
                 method: executeOptions.creatorInternals.transport,
+                route: (executeOptions.creator?.route ?? ''),
             },
             deps: executeOptions.deps,
             queryConfig: executeOptions.queryConfig,
@@ -4554,19 +4549,19 @@ const createGqlQueryCreator = (options, internals) => {
 
 /** A query creator that creates a GQL query where the payload is sent via GET (query params) */
 const createGqlQueryViaGet = (client) => {
-    return (creatorOptions) => createGqlQueryCreator(creatorOptions, { method: 'QUERY', client, transport: 'GET' });
+    return (query, creatorOptions) => createGqlQueryCreator(creatorOptions, { method: 'QUERY', client, transport: 'GET', query });
 };
 /** A query creator that creates a GQL query where the payload is sent via POST (body) */
 const createGqlQueryViaPost = (client) => {
-    return (creatorOptions) => createGqlQueryCreator(creatorOptions, { method: 'QUERY', client, transport: 'POST' });
+    return (query, creatorOptions) => createGqlQueryCreator(creatorOptions, { method: 'QUERY', client, transport: 'POST', query });
 };
 /** A query creator that creates a GQL mutation where the payload is sent via GET (query params) */
 const createGqlMutationViaGet = (client) => {
-    return (creatorOptions) => createGqlQueryCreator(creatorOptions, { method: 'MUTATE', client, transport: 'GET' });
+    return (query, creatorOptions) => createGqlQueryCreator(creatorOptions, { method: 'MUTATE', client, transport: 'GET', query });
 };
 /** A query creator that creates a GQL mutation where the payload is sent via POST (body) */
 const createGqlMutationViaPost = (client) => {
-    return (creatorOptions) => createGqlQueryCreator(creatorOptions, { method: 'MUTATE', client, transport: 'POST' });
+    return (query, creatorOptions) => createGqlQueryCreator(creatorOptions, { method: 'MUTATE', client, transport: 'POST', query });
 };
 
 const roomNotJoined = (room) => {