@tiesen/effect-tanstack-query 0.0.1

package/.github/workflows/ci.yml

@@ -0,0 +1,37 @@
+name: CI
+
+on:
+  pull_request:
+    branches: ['*']
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+env:
+  FORCE_COLOR: 3
+
+jobs:
+  format:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: ./.github/workflows/setup
+      - name: Format
+        run: bun format
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: ./.github/workflows/setup
+      - name: Lint
+        run: bun lint
+
+  typecheck:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: ./.github/workflows/setup
+      - name: Typecheck
+        run: bun typecheck

package/.github/workflows/release.yml

@@ -0,0 +1,25 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - main
+
+env:
+  FORCE_COLOR: 3
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v6
+      - uses: ./.github/workflows/setup
+
+      - name: Version & publish packages
+        run: bun tegami ci
+        env:
+          GITHUB_TOKEN: ${{ github.token }}

package/.github/workflows/setup/action.yml

@@ -0,0 +1,15 @@
+name: 'Setup Project'
+description: 'Checkouts repo, sets up bun and installs dependencies'
+runs:
+  using: 'composite'
+  steps:
+    - name: Setup Bun
+      uses: oven-sh/setup-bun@v2
+
+    - name: Install Dependencies
+      shell: bash
+      run: bun ci
+
+    - name: Build Packages
+      shell: bash
+      run: bun run build

package/.tegami/publish-lock.yaml

@@ -0,0 +1,13 @@
+core:changelogs:
+  - content: "---\npackages:\n  npm:@tiesen/effect-tanstack-query:\n    type: patch\n---\n\n## Initial Release\n\nFirst official release of `effect-tanstack-query` — a type-safe bridge between **Effect HTTP API clients** and **TanStack Query**.\n\n### Features\n\n- **TanStack Query Options Proxy**: Automatically generate `queryOptions`, `mutationOptions`, and `getQueryKey` from Effect `HttpApiClient` endpoints using ES6 Proxies.\n- **End-to-End Type Safety**:\n  - Full type inference for `params`, `query`, `headers`, and `payload` schema inputs.\n  - Automatic resolution of `Success` and `Error` response types.\n  - Unwrap Effect `Schema` types seamlessly for TanStack Query options.\n- **Smart Arguments**: Supports optional input parameters when an endpoint requires no request parameters/payload.\n- **Effect Runtime Execution**: Seamlessly executes Effect pipelines as Promises backed by `ManagedRuntime` and supports request cancellation via `AbortSignal`.\n"
+    filename: 2026-07-28-ms4c4sko.md
+    v: 0.0.0
+core:packages:
+  - changelogIds:
+      - 2026-07-28-ms4c4sko.md
+    id: npm:@tiesen/effect-tanstack-query
+    updated: true
+npm:mark-latest:
+  - id: npm:@tiesen/effect-tanstack-query
+npm:packages:
+  - id: npm:@tiesen/effect-tanstack-query

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+## @tiesen/effect-tanstack-query@0.0.1
+
+### Initial Release
+
+First official release of `effect-tanstack-query` — a type-safe bridge between **Effect HTTP API clients** and **TanStack Query**.
+
+### Features
+
+- **TanStack Query Options Proxy**: Automatically generate `queryOptions`, `mutationOptions`, and `getQueryKey` from Effect `HttpApiClient` endpoints using ES6 Proxies.
+- **End-to-End Type Safety**:
+  - Full type inference for `params`, `query`, `headers`, and `payload` schema inputs.
+  - Automatic resolution of `Success` and `Error` response types.
+  - Unwrap Effect `Schema` types seamlessly for TanStack Query options.
+- **Smart Arguments**: Supports optional input parameters when an endpoint requires no request parameters/payload.
+- **Effect Runtime Execution**: Seamlessly executes Effect pipelines as Promises backed by `ManagedRuntime` and supports request cancellation via `AbortSignal`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tiesen243
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,124 @@
+# effect-tanstack-query
+
+A lightweight, type-safe bridge between **Effect HTTP API clients** and **TanStack Query** (`queryOptions`, `mutationOptions`, and `getQueryKey`).
+
+## Features
+
+- **Seamless Integration**: Effortlessly map Effect `HttpApiClient` endpoints to TanStack Query config objects.
+- **End-to-End Type Safety**: Automatically infers inputs (`params`, `query`, `headers`, `payload`), success types, and error types directly from your Effect schemas.
+- **Zero Boilerplate**: Generates `queryKey` and execution functions under the hood using ES6 Proxies.
+- **Developer Friendly**: Smart optional parameters when no input arguments are required.
+
+## Installation
+
+Install using your preferred package manager:
+
+```bash
+# Using bun
+bun add effect-tanstack-query
+
+# Using pnpm
+pnpm add effect-tanstack-query
+
+# Using npm
+npm install effect-tanstack-query`
+```
+
+## Quick Start
+
+### 1. Define your Effect HTTP API Contract
+
+```ts
+import { Schema } from 'effect'
+import { HttpApi, HttpApiEndpoint, HttpApiGroup } from 'effect/unstable/httpapi'
+
+class ApiGroup extends HttpApiGroup.make('ApiGroup')
+  .add(
+    HttpApiEndpoint.get('hello', '/hello/:name', {
+      success: Schema.String,
+      params: Schema.Struct({
+        name: Schema.String,
+      }),
+      query: Schema.Struct({
+        greeting: Schema.String.pipe(Schema.optionalKey),
+      }),
+    })
+  )
+  .add(
+    HttpApiEndpoint.post('goodbye', '/goodbye', {
+      success: Schema.String,
+      payload: Schema.Struct({
+        name: Schema.String,
+      }),
+    })
+  ) {}
+
+export class Api extends HttpApi.make('Api').add(ApiGroup) {}
+```
+
+### 2. Create an Effect HTTP API Client
+
+```ts
+import { Context, Function, Layer } from 'effect'
+import {
+  FetchHttpClient,
+  HttpClient,
+  HttpClientRequest,
+} from 'effect/unstable/http'
+import { HttpApiClient } from 'effect/unstable/httpapi'
+
+class ApiClient extends Context.Service<
+  ApiClient,
+  HttpApiClient.ForApi<typeof Api>
+>()('ApiClient') {
+  public static live = Layer.effect(
+    this,
+    HttpApiClient.make(Api, {
+      transformClient: (client) =>
+        client.pipe(
+          HttpClient.mapRequest(
+            Function.flow(HttpClientRequest.prependUrl('http://localhost:3000'))
+          )
+        ),
+    })
+  ).pipe(Layer.provide(FetchHttpClient.layer))
+}
+```
+
+### 3. Use `effect-tanstack-query` to Generate Query and Mutation Options
+
+```ts
+import { ManagedRuntime } from 'effect'
+import { createTanstackQueryOptionsProxy } from 'effect-tanstack-query'
+
+const runtime = ManagedRuntime.make(ApiClient.live)
+const api = createTanstackQueryOptionsProxy(ApiClient, runtime)
+```
+
+### Usage
+
+```ts
+import { useMutation, useQueryClient, useQuery } from '@tanstack/react-query'
+
+// Query Example
+const query = useQuery(
+  api.ApiGroup.hello.queryOptions({
+    params: { name: 'John' },
+    query: { greeting: 'Hi' },
+  })
+)
+
+// Mutation Example
+const mutation = useMutation(api.ApiGroup.goodbye.mutationOptions())
+mutation.mutate({ name: 'John' })
+
+// Invalidate Query Example
+const queryClient = useQueryClient()
+void queryClient.invalidateQueries({
+  queryKey: api.ApiGroup.hello.getQueryKey(),
+})
+```
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

package/examples/client.ts

@@ -0,0 +1,36 @@
+import { QueryClient } from '@tanstack/query-core'
+import { Context, Function, Layer, ManagedRuntime } from 'effect'
+import {
+  FetchHttpClient,
+  HttpClient,
+  HttpClientRequest,
+} from 'effect/unstable/http'
+import { HttpApiClient } from 'effect/unstable/httpapi'
+
+import { createTanstackQueryOptionsProxy } from '../dist/index.mjs'
+import { Api } from './contract'
+
+class ApiClient extends Context.Service<
+  ApiClient,
+  HttpApiClient.ForApi<typeof Api>
+>()('ApiClient') {
+  public static live = Layer.effect(
+    this,
+    HttpApiClient.make(Api, {
+      transformClient: (client) =>
+        client.pipe(
+          HttpClient.mapRequest(
+            // oxlint-disable-next-line unicorn/max-nested-calls
+            Function.flow(HttpClientRequest.prependUrl('http://localhost:3000'))
+          )
+        ),
+    })
+  ).pipe(Layer.provide(FetchHttpClient.layer))
+}
+
+const runtime = ManagedRuntime.make(ApiClient.live)
+export const api = createTanstackQueryOptionsProxy(ApiClient, runtime)
+
+new QueryClient().invalidateQueries({
+  queryKey: api.ApiGroup.hello.getQueryKey(),
+})

package/examples/contract.ts

@@ -0,0 +1,28 @@
+// oxlint-disable max-classes-per-file
+
+import { Schema } from 'effect'
+import { HttpApi, HttpApiEndpoint, HttpApiGroup } from 'effect/unstable/httpapi'
+
+class ApiGroup extends HttpApiGroup.make('ApiGroup')
+  .add(
+    HttpApiEndpoint.get('hello', '/hello/:name', {
+      success: Schema.String,
+      params: Schema.Struct({
+        name: Schema.String,
+      }),
+      query: Schema.Struct({
+        // oxlint-disable-next-line unicorn/max-nested-calls
+        greeting: Schema.String.pipe(Schema.optionalKey),
+      }),
+    })
+  )
+  .add(
+    HttpApiEndpoint.post('goodbye', '/goodbye', {
+      success: Schema.String,
+      payload: Schema.Struct({
+        name: Schema.String,
+      }),
+    })
+  ) {}
+
+export class Api extends HttpApi.make('Api').add(ApiGroup) {}

package/examples/server.ts

@@ -0,0 +1,27 @@
+import { Effect, Layer } from 'effect'
+import { HttpRouter, HttpServer } from 'effect/unstable/http'
+import { HttpApiBuilder } from 'effect/unstable/httpapi'
+
+import { Api } from './contract'
+
+const ApiGroupLive = HttpApiBuilder.group(Api, 'ApiGroup', (handlers) =>
+  handlers
+    .handle('hello', ({ params, query }) =>
+      Effect.succeed(`${query.greeting ?? 'Hello'}, ${params.name}!`)
+    )
+    .handle('goodbye', ({ payload }) =>
+      Effect.succeed(`Goodbye, ${payload.name}!`)
+    )
+)
+
+const ApiLive = HttpApiBuilder.layer(Api, {
+  openapiPath: '/openapi.json',
+}).pipe(
+  Layer.provide([ApiGroupLive]),
+  Layer.provide(HttpRouter.cors()),
+  Layer.provide(HttpServer.layerServices)
+)
+
+export default {
+  fetch: HttpRouter.toWebHandler(ApiLive).handler,
+}

package/oxfmt.config.ts

@@ -0,0 +1,38 @@
+import { defineConfig } from 'oxfmt'
+
+export default defineConfig({
+  printWidth: 80,
+  tabWidth: 2,
+  arrowParens: 'always',
+  bracketSameLine: false,
+  bracketSpacing: true,
+  endOfLine: 'lf',
+  quoteProps: 'as-needed',
+  semi: false,
+  singleQuote: true,
+  jsxSingleQuote: true,
+  trailingComma: 'es5',
+  useTabs: false,
+
+  sortImports: {
+    groups: [
+      'side_effect_style',
+      'type-import',
+      ['value-builtin', 'value-external'],
+      'type-internal',
+      'value-internal',
+      ['type-parent', 'type-sibling', 'type-index'],
+      ['value-parent', 'value-sibling', 'value-index'],
+    ],
+    newlinesBetween: true,
+    order: 'asc',
+  },
+
+  sortPackageJson: {
+    sortScripts: true,
+  },
+
+  sortTailwindcss: {
+    functions: ['clsx', 'cva', 'cn'],
+  },
+})

package/oxlint.config.ts

@@ -0,0 +1,124 @@
+import { defineConfig } from 'oxlint'
+
+export default defineConfig({
+  plugins: [
+    'eslint',
+    'typescript',
+    'unicorn',
+    'oxc',
+    'import',
+    'jsdoc',
+    'node',
+    'promise',
+  ],
+  env: {
+    browser: true,
+  },
+  categories: {
+    correctness: 'error',
+    perf: 'error',
+    restriction: 'error',
+    suspicious: 'error',
+    pedantic: 'error',
+    style: 'error',
+  },
+  rules: {
+    'arrow-body-style': ['error', 'as-needed'],
+    'capitalized-comments': 'off',
+    curly: 'off',
+    'func-style': 'off',
+    'id-length': 'off',
+    'init-declarations': 'off',
+    'max-depth': 'off',
+    'max-lines': 'off',
+    'max-lines-per-function': 'off',
+    'max-params': 'off',
+    'max-statements': 'off',
+    'new-cap': 'off',
+    'no-await-in-loop': 'off',
+    'no-console': 'off',
+    'no-continue': 'off',
+    'no-duplicate-imports': ['error', { allowSeparateTypeImports: true }],
+    'no-implicit-coercion': 'off',
+    'no-inline-comments': 'off',
+    'no-magic-numbers': 'off',
+    'no-use-before-define': 'off',
+    'no-ternary': 'off',
+    'no-undefined': 'off',
+    // Avoid conflict with typescript/no-floating-promises
+    'no-void': ['error', { allowAsStatement: true }],
+    'sort-keys': 'off',
+    // Rely on oxfmt `sortImports` instead
+    'sort-imports': 'off',
+
+    'import/consistent-type-specifier-style': ['error', 'prefer-top-level'],
+    'import/exports-last': 'off',
+    'import/extensions': 'off',
+    'import/group-exports': 'off',
+    'import/max-dependencies': 'off',
+    'import/no-anonymous-default-export': 'off',
+    'import/no-commonjs': 'off',
+    'import/no-default-export': 'off',
+    'import/no-dynamic-require': 'off',
+    'import/no-named-export': 'off',
+    'import/no-namespace': 'off',
+    'import/no-nodejs-modules': 'off',
+    'import/no-relative-parent-imports': 'off',
+    'import/no-unassigned-import': 'off',
+    'import/prefer-default-export': 'off',
+    'import/unambiguous': 'off',
+
+    'jsdoc/require-param': 'off',
+    'jsdoc/require-param-type': 'off',
+    'jsdoc/require-returns': 'off',
+    'jsdoc/require-returns-type': 'off',
+
+    'unicorn/explicit-length-check': 'off',
+    'unicorn/no-array-callback-reference': 'off',
+    'unicorn/no-null': 'off',
+    'unicorn/no-process-exit': 'off',
+    'unicorn/number-literal-case': 'off',
+    'unicorn/prefer-global-this': 'off',
+    'unicorn/prefer-string-raw': 'off',
+    'unicorn/prefer-top-level-await': 'off',
+
+    'typescript/explicit-function-return-type': 'off',
+    'typescript/explicit-module-boundary-types': 'off',
+    'typescript/no-require-imports': 'off',
+    'typescript/no-var-requires': 'off',
+    'typescript/no-namespace': 'off',
+    'typescript/require-await': 'off',
+
+    'node/no-process-env': 'off',
+
+    'oxc/no-async-await': 'off',
+    'oxc/no-map-spread': 'off',
+    'oxc/no-optional-chaining': 'off',
+    'oxc/no-rest-spread-properties': 'off',
+
+    'promise/always-return': 'off',
+    'promise/catch-or-return': 'off',
+  },
+  overrides: [
+    {
+      // Shared test file overrides — framework-specific test rules
+      // are in separate jest/ and vitest/ configs to avoid conflicts.
+      files: [
+        '**/*.{test,spec}.{ts,tsx,js,jsx}',
+        '**/__tests__/**/*.{ts,tsx,js,jsx}',
+      ],
+      rules: {
+        // Disabled: mock callbacks often need empty functions
+        'no-empty-function': 'off',
+        // Disabled: mock factories use Promise.resolve/reject (conflicts with require-await)
+        'promise/prefer-await-to-then': 'off',
+      },
+    },
+    {
+      files: ['**/env.ts'],
+      rules: {
+        'node/no-process-env': 'off',
+      },
+    },
+  ],
+})

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@tiesen/effect-tanstack-query",
+  "version": "0.0.1",
+  "private": false,
+  "type": "module",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "format": "oxfmt --check",
+    "format:fix": "oxfmt",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "tegami": "bun run tegami.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "oxfmt": "^0.61.0",
+    "oxlint": "^1.76.0",
+    "tegami": "^1.2.7",
+    "tsdown": "^0.22.14",
+    "typescript": "^7.0.2"
+  },
+  "peerDependencies": {
+    "@tanstack/query-core": ">=5.100.0",
+    "effect": ">=4.0.0-beta.100 || >=4.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,137 @@
+import type { MutationOptions, QueryOptions } from '@tanstack/query-core'
+import type { Service } from 'effect/Context'
+import type { ManagedRuntime } from 'effect/ManagedRuntime'
+
+import * as Effect from 'effect/Effect'
+
+import type { TanstackQueryOptionsProxy } from './types'
+
+/**
+ * Creates a type-safe proxy that bridges Effect `HttpApiClient` endpoints
+ * with TanStack Query options (`queryOptions`, `mutationOptions`, and `getQueryKey`).
+ *
+ * @param tag - The Effect `Service` tag used to locate the client implementation within the Context.
+ * @param runtime - The Effect `ManagedRuntime` used to execute effects as promises.
+ *
+ * @returns A proxy object structured like the target API client, providing TanStack Query helpers for each endpoint.
+ *
+ * @example
+ * ```ts
+ * class ApiGroup extends HttpApiGroup.make('ApiGroup')
+ *  .add(HttpApiEndpoint.get('hello', '/hello', { success: Schema.String, query: Schema.Struct({ name: Schema.String }) }))
+ *  .add(HttpApiEndpoint.post('bye', '/bye', { success: Schema.String, payload: Schema.Struct({ name: Schema.String }) })) {}
+ *
+ * class Api extends HttpApi.make('Api').add(ApiGroup) {}
+ *
+ * class ApiClient extends Context.Service<ApiClient, HttpApiClient.ForApi<typeof Api>>()('ApiClient') {
+ *  public static live = Layer.effect(this, HttpApiClient.make(Api)).pipe(Layer.provide(FetchHttpClient.layer))
+ * }
+ *
+ * const runtime = ManagedRuntime.make(ApiClient.live)
+ * const api = createTanstackQueryOptionsProxy(ApiClient, runtime);
+ *
+ * // Example usage in a React component with TanStack Query
+ * const { data } = useQuery(api.hello.queryOptions({ query: { name: 'World' } }))
+ * //       ^? const data: string = "Hello, World!"
+ *
+ * const { mutate, data } = useMutation(api.bye.mutationOptions())
+ * //               ^? const data: string = "Goodbye, World!"
+ * mutate({ name: 'World' })
+ * ```
+ */
+function createTanstackQueryOptionsProxy<TServiceTag, TService>(
+  tag: Service<TServiceTag, TService>,
+  runtime: ManagedRuntime<TServiceTag, never>
+): TanstackQueryOptionsProxy<TService> {
+  /**
+   * Internal cache for memoizing Proxy instances to avoid unnecessary re-allocations.
+   */
+  const cache = new Map<string, unknown>()
+
+  /**
+   * Recursively creates or retrieves a cached Proxy instance for a given property path.
+   *
+   * @param path - An array of property keys representing the object trajectory (e.g., `['users', 'getById', 'queryOptions']`).
+   * @returns A proxy function handling property accesses and method invocations.
+   */
+  const createProxy = (path: string[]): unknown => {
+    const cacheKey = path.join('.')
+    if (cache.has(cacheKey)) return cache.get(cacheKey)
+
+    const proxy = new Proxy(
+      () => {
+        // This function is intentionally left empty. The proxy will handle method calls and property accesses.
+      },
+      {
+        get(_target, prop) {
+          if (typeof prop === 'symbol' || prop === 'then') return
+          return createProxy([...path, String(prop)])
+        },
+
+        apply(_target, _thisArg, args) {
+          const action = path.at(-1)
+          const apiPath = path.slice(0, -1)
+          const [input, options] = args
+
+          /**
+           * Executes the targeted Effect HTTP API endpoint by navigating the service instance.
+           *
+           * @param params - Parameters/payload passed into the target endpoint function.
+           * @param signal - Optional `AbortSignal` for canceling request execution.
+           * @returns A Promise resolving to the Effect result.
+           */
+          const execute = (params: unknown, signal?: AbortSignal) =>
+            runtime.runPromise(
+              Effect.gen(function* executeGen() {
+                // oxlint-disable-next-line typescript/no-explicit-any
+                const api: any = yield* tag
+
+                let fn = api
+                for (const p of apiPath) fn = fn[p]
+
+                return yield* fn(params)
+              }) as Effect.Effect<unknown, unknown, TServiceTag>,
+              { signal }
+            )
+
+          /**
+           * Constructs a consistent, structured array key for TanStack Query caching.
+           *
+           * @param queryType - The operation type (`'query'` or `'mutation'`).
+           * @param inp - The input parameters or payload associated with the endpoint request.
+           * @returns A read-only query key array.
+           */
+          const createKey = (queryType: string, inp: unknown) => [
+            { type: queryType },
+            ...apiPath,
+            ...(inp ? [inp] : []),
+          ]
+
+          if (action === 'queryOptions')
+            return {
+              ...options,
+              queryKey: createKey('query', input),
+              queryFn: ({ signal }) => execute(input, signal),
+            } satisfies QueryOptions
+
+          if (action === 'getQueryKey') return createKey('query', input)
+
+          if (action === 'mutationOptions')
+            return {
+              ...options,
+              mutationKey: createKey('mutation', input),
+              mutationFn: (payload) => execute({ payload }),
+            } satisfies MutationOptions
+        },
+      }
+    )
+
+    cache.set(cacheKey, proxy)
+    return proxy
+  }
+
+  return createProxy([]) as TanstackQueryOptionsProxy<TService>
+}
+
+export type { TanstackQueryOptionsProxy } from './types'
+export { createTanstackQueryOptionsProxy }

package/src/types.ts

@@ -0,0 +1,93 @@
+// oxlint-disable typescript/no-empty-object-type typescript/ban-types
+
+import type { MutationOptions, QueryOptions } from '@tanstack/query-core'
+import type { Schema } from 'effect/Schema'
+import type { Client } from 'effect/unstable/httpapi/HttpApiClient'
+import type { HttpApiEndpoint } from 'effect/unstable/httpapi/HttpApiEndpoint'
+
+export type TanstackQueryOptionsProxy<T> =
+  T extends Client.Method<
+    HttpApiEndpoint<
+      infer _Key,
+      infer Method,
+      infer _Path,
+      infer Params,
+      infer Query,
+      infer Payload,
+      infer Headers,
+      infer Success,
+      infer Error
+    >,
+    infer _Error,
+    infer _Requires
+  >
+    ? {
+        queryOptions: Method extends 'GET'
+          ? <TQuery = QueryOptions<UnwrapCodec<Success>, UnwrapCodec<Error>>>(
+              input: MakeOptionalInput<
+                ([Params] extends [never]
+                  ? {}
+                  : { params: UnwrapCodec<Params> }) &
+                  ([Query] extends [never]
+                    ? {}
+                    : { query: UnwrapCodec<Query> }) &
+                  ([Headers] extends [never]
+                    ? {}
+                    : { headers: UnwrapCodec<Headers> })
+              >,
+              options?: Omit<TQuery, 'queryKey' | 'queryFn'>
+            ) => TQuery
+          : never
+        mutationOptions: Method extends 'GET'
+          ? never
+          : <
+              TMutation = MutationOptions<
+                UnwrapCodec<Success>,
+                UnwrapCodec<Error>,
+                UnwrapCodec<Payload>
+              >,
+            >(
+              input: MakeOptionalInput<
+                ([Params] extends [never]
+                  ? {}
+                  : { params: UnwrapCodec<Params> }) &
+                  ([Headers] extends [never]
+                    ? {}
+                    : { headers: UnwrapCodec<Headers> })
+              >,
+              options?: Omit<TMutation, 'mutationKey' | 'mutationFn'>
+            ) => TMutation
+
+        getQueryKey: Method extends 'GET'
+          ? (
+              input?: Partial<
+                MakeOptionalInput<
+                  ([Params] extends [never]
+                    ? {}
+                    : { params: UnwrapCodec<Params> }) &
+                    ([Query] extends [never]
+                      ? {}
+                      : { query: UnwrapCodec<Query> }) &
+                    ([Headers] extends [never]
+                      ? {}
+                      : { headers: UnwrapCodec<Headers> })
+                >
+              >
+            ) => readonly unknown[]
+          : never
+      }
+    : T extends object
+      ? {
+          readonly [K in keyof T]: TanstackQueryOptionsProxy<T[K]>
+        }
+      : T
+
+type UnwrapCodec<T> =
+  T extends Schema<unknown>
+    ? Schema.Type<T>
+    : T extends object
+      ? { [K in keyof T]: UnwrapCodec<T[K]> }
+      : T
+
+// oxlint-disable-next-line typescript/no-invalid-void-type
+type MakeOptionalInput<T> = keyof T extends never ? void | undefined : T

package/tegami.ts

@@ -0,0 +1,27 @@
+import { tegami } from 'tegami'
+import { runCli } from 'tegami/cli'
+import { github } from 'tegami/plugins/github'
+
+const paper = tegami({
+  npm: {
+    client: 'bun',
+    updateLockFile: true,
+    onBreakPeerDep: 'set',
+    trustedPublish: {
+      provider: 'github',
+      workflow: 'release.yml',
+    },
+  },
+
+  plugins: [
+    github({
+      repo: 'tiesen243/effect-tanstack-query',
+      versionPr: {
+        base: 'main',
+      },
+    }),
+  ],
+})
+
+// oxlint-disable-next-line node/no-top-level-await
+await runCli(paper)

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["es2024", "dom"],
+    "target": "es2024",
+    "module": "preserve",
+    "moduleDetection": "force",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  },
+  "include": ["src/*.ts", "examples/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsdown.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'tsdown'
+
+export default defineConfig({
+  entry: './src/index.ts',
+  dts: true,
+  minify: true,
+  shims: true,
+})