query options override on query level

src/App.tsx

@@ -265,6 +265,7 @@ const queryRouteResult = createQueryRoutes({
                 }
             `],
             component: LeftMenu,
+            //cacheTimeout: 10_000 //override works
         },
         category: {
             path: '/category/:_id',

src/lib/pub/query/index.ts

@@ -30,15 +30,15 @@ const defaultOptions:CreateQueryPubOptions = {
     forceRefreshAfterTimeout: true,
 }
 
-export default (options:CreateQueryPubOptions) => {
+export default (globalOptions:CreateQueryPubOptions) => {
     const queryPub        = createPub({queries: {}, mutations: {}})
     const currentPromises =           {queries: {}, mutations: {}}
 
-    options.cacheTimeout              ||= defaultOptions.cacheTimeout
+    globalOptions.cacheTimeout              ||= defaultOptions.cacheTimeout
 
-    options.hidePendingOnRefresh        = options.hidePendingOnRefresh     === undefined ? defaultOptions.hidePendingOnRefresh     : options.hidePendingOnRefresh
-    options.avoidRepeatInProgress       = options.avoidRepeatInProgress    === undefined ? defaultOptions.avoidRepeatInProgress    : options.avoidRepeatInProgress
-    options.forceRefreshAfterTimeout    = options.forceRefreshAfterTimeout === undefined ? defaultOptions.forceRefreshAfterTimeout : options.forceRefreshAfterTimeout
+    globalOptions.hidePendingOnRefresh        = globalOptions.hidePendingOnRefresh     === undefined ? defaultOptions.hidePendingOnRefresh     : globalOptions.hidePendingOnRefresh
+    globalOptions.avoidRepeatInProgress       = globalOptions.avoidRepeatInProgress    === undefined ? defaultOptions.avoidRepeatInProgress    : globalOptions.avoidRepeatInProgress
+    globalOptions.forceRefreshAfterTimeout    = globalOptions.forceRefreshAfterTimeout === undefined ? defaultOptions.forceRefreshAfterTimeout : globalOptions.forceRefreshAfterTimeout
 
 
     /*
@@ -48,14 +48,18 @@ export default (options:CreateQueryPubOptions) => {
      * @returns {function} "createQuery", which receives promise name for pub, isMutation flag, cacheTagsFunc and query function arguments 
      */
     const withQueryFunc = (queryFunc?: QueryFuncType):Function => {
-        //TODO: give ability of options override
         //TODO: type params
-        return ({promiseName, name, isMutation, cacheTagsFunc, args=[]}) => {
+        return ({promiseName, name, isMutation, cacheTagsFunc, args=[], cacheTimeout, hidePendingOnRefresh, avoidRepeatInProgress, forceRefreshAfterTimeout}) => {
             promiseName = promiseName || name
 
             const qF = queryFunc || options.queryFunc
             const defaultArgs = args
-            
+
+            cacheTimeout ||= globalOptions.cacheTimeout
+
+            hidePendingOnRefresh        = hidePendingOnRefresh     === undefined ? globalOptions.hidePendingOnRefresh     : hidePendingOnRefresh
+            avoidRepeatInProgress       = avoidRepeatInProgress    === undefined ? globalOptions.avoidRepeatInProgress    : avoidRepeatInProgress
+            forceRefreshAfterTimeout    = forceRefreshAfterTimeout === undefined ? globalOptions.forceRefreshAfterTimeout : forceRefreshAfterTimeout
 
             /*
              * Concats default arguments from withQueryFunc resulting function with passed arguments
@@ -119,11 +123,11 @@ export default (options:CreateQueryPubOptions) => {
              */
             const query = (...args:any[]) => {
                 if (isMutation){
-                    if (options.avoidRepeatInProgress && queryPub.mutations[promiseName]?.refreshing){
+                    if (avoidRepeatInProgress && queryPub.mutations[promiseName]?.refreshing){
                         return currentPromises.mutations[promiseName]
                     }
                     else {
-                        if (!options.hidePendingOnRefresh || !queryPub.mutations[promiseName]){
+                        if (!hidePendingOnRefresh || !queryPub.mutations[promiseName]){
                             queryPub.mutations[promiseName] = {status: 'PENDING', refreshing: true}
                         }
                         if (!queryPub.mutations[promiseName].refreshing){
@@ -135,8 +139,8 @@ export default (options:CreateQueryPubOptions) => {
                 }
                 if (!isMutation){
                     const stringifiedArgs = stringifyArgs(args)
-                    if (((!options.cacheTimeout && queryPub.queries[promiseName]?.[stringifiedArgs].status === 'FULFILLED') || 
-                        (queryPub.queries[promiseName]?.[stringifiedArgs] && (Date.now() - queryPub.queries[promiseName][stringifiedArgs].timeStamp) < options.cacheTimeout)) &&
+                    if (((!cacheTimeout && queryPub.queries[promiseName]?.[stringifiedArgs].status === 'FULFILLED') || 
+                        (queryPub.queries[promiseName]?.[stringifiedArgs] && (Date.now() - queryPub.queries[promiseName][stringifiedArgs].timeStamp) < cacheTimeout)) &&
                          !queryPub.queries[promiseName]?.[stringifiedArgs].invalidated){
 
                         return currentPromises.queries[promiseName][stringifiedArgs] 
@@ -166,11 +170,11 @@ export default (options:CreateQueryPubOptions) => {
                 }
 
 
-                if (options.avoidRepeatInProgress && queryPub.queries[promiseName]?.[stringifiedArgs]?.refreshing){
+                if (avoidRepeatInProgress && queryPub.queries[promiseName]?.[stringifiedArgs]?.refreshing){
                     return currentPromises.queries[promiseName][stringifiedArgs]
                 }
 
-                if (!options.hidePendingOnRefresh || !queryPub.queries[promiseName]?.[stringifiedArgs]){
+                if (!hidePendingOnRefresh || !queryPub.queries[promiseName]?.[stringifiedArgs]){
                     queryPub.queries[promiseName][stringifiedArgs] = {status: 'PENDING', timeStamp: Date.now(), refreshing: true}
                 }
 
@@ -190,13 +194,13 @@ export default (options:CreateQueryPubOptions) => {
                                                                                                                                                             payload, 
                                                                                                                                                             timeStamp: Date.now(), 
                                                                                                                                                             cacheTags: cacheTagsFunc && cacheTagsFunc(payload),
-                                                                                                                                                            timeoutId: options.cacheTimeout && options.forceRefreshAfterTimeout ? setTimeout(() =>forceQuery(...args), options.cacheTimeout) : null
+                                                                                                                                                            timeoutId: cacheTimeout && forceRefreshAfterTimeout ? setTimeout(() =>forceQuery(...args), cacheTimeout) : null
                                                                                                                                                         },
                                                                                            error   => queryPub.queries[promiseName][stringifiedArgs] = {
                                                                                                                                                             status: 'REJECTED', 
                                                                                                                                                             error, 
                                                                                                                                                             timeStamp: Date.now(),
-                                                                                                                                                            timeoutId: options.cacheTimeout && options.forceRefreshAfterTimeout ? setTimeout(() =>forceQuery(...args), options.cacheTimeout) : null
+                                                                                                                                                            timeoutId: cacheTimeout && forceRefreshAfterTimeout ? setTimeout(() =>forceQuery(...args), cacheTimeout) : null
                                                                                                                                                         })
             }
 
@@ -265,5 +269,5 @@ export default (options:CreateQueryPubOptions) => {
         //console.log('AFTER flush',JSON.stringify(queryPub, null, 4))
     }
 
-    return {queryPub, withQueryFunc, ...(options.queryFunc ? {createQuery: withQueryFunc(options.queryFunc)}: {}), flushCache}
+    return {queryPub, withQueryFunc, ...(globalOptions.queryFunc ? {createQuery: withQueryFunc(globalOptions.queryFunc)}: {}), flushCache}
 }

src/lib/queryRoute/index.tsx

@@ -10,14 +10,13 @@ export type QueryRoute = {
     //if set, routing can't work
     isMutation?: boolean,
     /*
-    //TODO; options override in query on createQuery level
     //it aren't works for now
     query: QueryFuncType,
+    */
     cacheTimeout?: number,
     hidePendingOnRefresh?: boolean
     avoidRepeatInProgress?: boolean,
     forceRefreshAfterTimeout?: boolean,
-    */
 
 
 
@@ -140,7 +139,8 @@ export const createQueryRoutes = (options:CreateQueryRoutesOptions):CreateQueryR
     const queryRoutesResults:QueryRoutesResults = {};
 
     for (const [name, queryRoute] of Object.entries(options.queryRoutes)){
-        const {path, args, component, Pending, Error:ErrorComponent, errorQueryComponentErrorProp:errorProp, componentQueryResultProp:resultProp, cacheTagsFunc, roles, fallback, isMutation} = queryRoute
+        const {path, args, component, Pending, Error:ErrorComponent, errorQueryComponentErrorProp:errorProp, componentQueryResultProp:resultProp, roles, fallback,
+                cacheTagsFunc,  isMutation, cacheTimeout, avoidRepeatInProgress, hidePendingOnRefresh, forceRefreshAfterTimeout} = queryRoute
 
         const camelCaseName = name[0].toUpperCase() + name.slice(1)
 
@@ -149,7 +149,7 @@ export const createQueryRoutes = (options:CreateQueryRoutesOptions):CreateQueryR
         let queryRouteResult:QueryRouteResult = {}
 
         if (args){
-            const createQueryResult = queryPubResult.createQuery({name, isMutation, cacheTagsFunc, args})
+            const createQueryResult = queryPubResult.createQuery({name, isMutation, cacheTagsFunc, args, cacheTimeout, avoidRepeatInProgress, hidePendingOnRefresh, forceRefreshAfterTimeout })
             const {makeQuery, query, forceQuery, hook, hookName} = createQueryResult
 
             queryRouteResult = {