feat: implement queryOptions export pattern and type-safe query key builder

.gitignore

@@ -130,3 +130,7 @@ dist
 .pnp.*
 
 lib/
+
+# Project-specific files
+plan/
+CLAUDE.md

CHANGELOG.md

@@ -0,0 +1,38 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0] - TBD
+
+### Changed
+
+- **BREAKING**: Migrated from wrapper hooks to queryOptions/mutationOptions export pattern
+  - Changed from `useWidgets()` to `getWidgetsQueryOptions()`
+  - Changed from `useCreateWidget()` to `createWidgetMutationOptions()`
+  - Changed from `useInfiniteWidgets()` to `getWidgetsInfiniteQueryOptions()`
+- **BREAKING**: Updated query key structure for better cache management
+  - From: `['/widgets', compact({ status: params?.status })].filter(Boolean)`
+  - To: `['widget', 'getWidgets', params || {}] as const`
+- Added non-hook service getters in context for use in queryOptions
+
+### Added
+
+- Type-safe `matchQueryKey` function for building query keys with IntelliSense support
+  - Supports partial query matching at service, operation, or full parameter levels
+  - Provides compile-time type safety and autocomplete for all query operations
+  - Enables flexible cache invalidation patterns
+- Test coverage for infinite query options generation
+- Support for direct composition with React Query hooks
+- Better TypeScript inference with queryOptions pattern
+
+### Removed
+
+- Wrapper hook functions (use queryOptions with React Query hooks directly)
+- Complex query key filtering logic
+
+## [0.1.x] - Previous versions
+
+Initial implementation with wrapper hooks pattern.

README.md

@@ -3,13 +3,14 @@
 
 # React Query
 
-[Basketry generator](https://github.com/basketry/basketry) for generating React Query hooks. This parser can be coupled with any Basketry parser.
+[Basketry generator](https://basketry.io) for generating [React Query](https://tanstack.com/query) (TanStack Query) hooks and query/mutation options. This generator can be coupled with any Basketry parser to automatically generate type-safe React Query integration from your API definitions.
 
-## Quick Start
+## Features
 
-// TODO
-
----
+- Generates type-safe query and mutation options following React Query v5 patterns
+- Type-safe query key builder for cache operations with IntelliSense support
+- Support for infinite queries with Relay-style pagination
+- Full TypeScript support with proper type inference
 
 ## For contributors:
 

src/context-file.ts

@@ -1,8 +1,10 @@
 import { camel, pascal } from 'case';
 import { ModuleBuilder } from './module-builder';
 import { ImportBuilder } from './import-builder';
+import { NameFactory } from './name-factory';
 
 export class ContextFile extends ModuleBuilder {
+  private readonly nameFactory = new NameFactory(this.service, this.options);
   private readonly react = new ImportBuilder('react');
   private readonly client = new ImportBuilder(
     this.options?.reactQuery?.clientModule ?? '../http-client',
@@ -23,23 +25,43 @@ export class ContextFile extends ModuleBuilder {
     const FetchLike = () => this.client.type('FetchLike');
     const OptionsType = () => this.client.type(optionsName);
 
-    yield `export interface ClientContextProps { fetch: ${FetchLike()}; options: ${OptionsType()}; }`;
-    yield `const ClientContext = ${createContext()}<ClientContextProps | undefined>( undefined );`;
+    const contextName = this.nameFactory.buildContextName();
+    const contextPropsName = pascal(`${contextName}_props`);
+    const providerName = this.nameFactory.buildProviderName();
+
+    yield `export interface ${contextPropsName} { fetch: ${FetchLike()}; options: ${OptionsType()}; }`;
+    yield `const ${contextName} = ${createContext()}<${contextPropsName} | undefined>( undefined );`;
+    yield ``;
+    // Store context for non-hook access
+    yield `let currentContext: ${contextPropsName} | undefined;`;
     yield ``;
-    yield `export const ClientProvider: ${FC()}<${PropsWithChildren()}<ClientContextProps>> = ({ children, fetch, options }) => {`;
+    yield `export const ${providerName}: ${FC()}<${PropsWithChildren()}<${contextPropsName}>> = ({ children, fetch, options }) => {`;
     yield `  const value = ${useMemo()}(() => ({ fetch, options }), [fetch, options.mapUnhandledException, options.mapValidationError, options.root]);`;
-    yield `  return <ClientContext.Provider value={value}>{children}</ClientContext.Provider>;`;
+    yield `  currentContext = value;`;
+    yield `  return <${contextName}.Provider value={value}>{children}</${contextName}.Provider>;`;
     yield `};`;
     for (const int of this.service.interfaces) {
-      const hookName = camel(`use_${int.name.value}_service`);
-      const localName = camel(`${int.name.value}_service`);
+      const hookName = this.nameFactory.buildServiceHookName(int);
+      const localName = this.nameFactory.buildServiceName(int);
       const interfaceName = pascal(`${int.name.value}_service`);
       const className = pascal(`http_${int.name.value}_service`);
 
+      const getterName = camel(`get_${int.name.value}_service`);
+
+      yield ``;
+      yield `export const ${getterName} = () => {`;
+      yield `  if (!currentContext) { throw new Error('${getterName} called outside of ${providerName}'); }`;
+      yield `  const ${localName}: ${this.types.type(
+        interfaceName,
+      )} = new ${this.client.fn(
+        className,
+      )}(currentContext.fetch, currentContext.options);`;
+      yield `  return ${localName};`;
+      yield `}`;
       yield ``;
       yield `export const ${hookName} = () => {`;
-      yield `  const context = ${useContext()}(ClientContext);`;
-      yield `  if (!context) { throw new Error('${hookName} must be used within a ClientProvider'); }`;
+      yield `  const context = ${useContext()}(${contextName});`;
+      yield `  if (!context) { throw new Error('${hookName} must be used within a ${providerName}'); }`;
       yield `  const ${localName}: ${this.types.type(
         interfaceName,
       )} = new ${this.client.fn(className)}(context.fetch, context.options);`;