@wishknish/knishio-client-ts 0.8.0 → 0.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wishknish/knishio-client-ts",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "productName": "Knish.IO TypeScript SDK Client",
   "description": "TypeScript implementation of the Knish.IO SDK to consume Knish.IO GraphQL APIs with enhanced type safety.",
   "license": "GPL-3.0-or-later",

package/src/KnishIOClient.ts

@@ -568,7 +568,11 @@ export default class KnishIOClient {
   /**
    * Executes a query or mutation
    */
-  async executeQuery(query: Query | Mutation, variables: Record<string, any> | null = null): Promise<Response | null> {
+  async executeQuery(
+    query: Query | Mutation,
+    variables: Record<string, any> | null = null,
+    context: Record<string, any> = {}
+  ): Promise<Response | null> {
     // Check and refresh authorization token if needed
     // Guard with $__authInProcess to prevent recursive auth refresh
     if (this.$__authToken && this.$__authToken.isExpired() && !this.$__authInProcess) {
@@ -581,6 +585,8 @@ export default class KnishIOClient {
     }
 
     if (query instanceof MutationProposeMolecule) {
+      // Molecule submissions are writes — never cached, so no request-policy
+      // context applies; MutationProposeMolecule.execute takes only variables.
       return await this.withMoleculeLock(async () => {
         const response = await query.execute({ variables: variables || {} })
         this.handlePositionDrift(response)
@@ -588,8 +594,9 @@ export default class KnishIOClient {
       })
     }
 
-    // Execute the query
-    return await query.execute({ variables: variables || {} })
+    // Execute the query/mutation, forwarding any urql context (e.g.
+    // requestPolicy) assembled by the caller (queryMeta) / createQueryContext().
+    return await query.execute({ variables: variables || {}, context })
   }
 
   /**
@@ -1038,7 +1045,8 @@ export default class KnishIOClient {
     throughMolecule = false,
     values = null,
     keys = null,
-    atomValues = null
+    atomValues = null,
+    requestPolicy = null
   }: {
     metaType: MetaType | string
     metaId?: MetaId | string | null
@@ -1055,6 +1063,12 @@ export default class KnishIOClient {
     values?: any[] | null
     keys?: string[] | null
     atomValues?: any[] | null
+    /**
+     * urql request policy for this read. Pass 'network-only' to bypass the
+     * client's in-memory cache (e.g. sync engines that must see the current
+     * ledger state). Default null = urql's default (cache-first).
+     */
+    requestPolicy?: 'cache-first' | 'cache-only' | 'network-only' | 'cache-and-network' | null
   }): Promise<Response> {
     this.log('info', `KnishIOClient::queryMeta() - Querying metaType: ${metaType}, metaId: ${metaId}...`)
 
@@ -1109,7 +1123,8 @@ export default class KnishIOClient {
       })
     }
 
-    return this.executeQuery(query, variables) as Promise<Response>
+    const context = requestPolicy ? { requestPolicy } : {}
+    return this.executeQuery(query, variables, context) as Promise<Response>
   }
 
   /**

package/src/libraries/GraphQLClient.ts

@@ -159,18 +159,21 @@ export default class GraphQLClient implements IGraphQLClient {
   async query<TResult = unknown>(
     request: GraphQLRequest
   ): Promise<GraphQLResponse<TResult>> {
-    const { query, variables } = request
-    const result = await this.$__client.query(query, variables || {}).toPromise()
+    const { query, variables, context } = request
+    // Forward the urql context (e.g. requestPolicy: 'network-only'). Without
+    // this 3rd arg urql ignores requestPolicy and defaults to cache-first,
+    // serving stale results from a long-lived client's in-memory cache.
+    const result = await this.$__client.query(query, variables || {}, context).toPromise()
     return this.formatResponse<TResult>(result)
   }
 
   async mutation<TResult = unknown>(
     request: GraphQLRequest
   ): Promise<GraphQLResponse<TResult>> {
-    const { query, variables } = request
+    const { query, variables, context } = request
     // Support both query and mutation properties for backward compatibility
     const mutationString = (request as any).mutation || query
-    const result = await this.$__client.mutation(mutationString, variables || {}).toPromise()
+    const result = await this.$__client.mutation(mutationString, variables || {}, context).toPromise()
     return this.formatResponse<TResult>(result)
   }
 

package/src/query/QueryActiveSession.ts

@@ -71,6 +71,7 @@ export default class QueryActiveSession extends Query {
           metaId
           jsonData
           createdAt
+          updatedAt
         }
       }
     `

package/src/types/index.ts

@@ -375,6 +375,13 @@ export interface GraphQLRequest {
   query: string
   variables?: Record<string, unknown>
   operationName?: string | null
+  /**
+   * Per-operation urql context (e.g. `{ requestPolicy: 'network-only' }`).
+   * Built by Query.execute() from createQueryContext() + per-call context and
+   * MUST be forwarded to the urql client, or requestPolicy is silently ignored
+   * and urql falls back to its default cache-first policy.
+   */
+  context?: Record<string, unknown>
 }
 
 export interface GraphQLResponse<T = unknown> {