@openapi-qraft/react 1.0.0-beta.0

package/dist/qraftAPIClient.d.ts

@@ -0,0 +1,25 @@
+import { Context } from 'react';
+import { QraftContextValue } from './QraftContext.js';
+import type { RequestClientSchema } from './RequestClient.js';
+export type QraftClientOptions = {
+    context?: Context<QraftContextValue>;
+};
+export declare const qraftAPIClient: <Services extends { [service in keyof Services]: { [method in keyof Services[service]]: {
+    schema: RequestClientSchema;
+}; }; }, Callbacks extends Record<string, (...rest: any[]) => any>>(services: { [service_1 in keyof Services]: { [method_1 in keyof Services[service_1]]: {
+    schema: Services[service_1][method_1]["schema"];
+}; }; }, callbacks: Callbacks, options?: QraftClientOptions) => ServicesCallbacksFilter<Services, keyof Callbacks>;
+type ServicesCallbacksFilter<Services, Callbacks> = Services extends {
+    [serviceName in keyof Services]: {
+        [method in keyof Services[serviceName]]: {
+            schema: RequestClientSchema;
+        };
+    };
+} ? {
+    [serviceName in keyof Services]: {
+        [method in keyof Services[serviceName]]: Pick<Services[serviceName][method], FilterKeys<keyof Services[serviceName][method], Callbacks | 'schema'>>;
+    };
+} : never;
+type FilterKeys<T, K> = K extends T ? K : never;
+export {};
+//# sourceMappingURL=qraftAPIClient.d.ts.map

package/dist/qraftAPIClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qraftAPIClient.d.ts","sourceRoot":"","sources":["../src/qraftAPIClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAGhC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;CACtC,CAAC;AAEF,eAAO,MAAM,cAAc;YAG0B,mBAAmB;oDAG3B,GAAG,EAAE,KAAK,GAAG;;yCAU9C,kBAAkB,uDAoB7B,CAAC;AAeF,KAAK,uBAAuB,CAAC,QAAQ,EAAE,SAAS,IAAI,QAAQ,SAAS;KAClE,WAAW,IAAI,MAAM,QAAQ,GAAG;SAC9B,MAAM,IAAI,MAAM,QAAQ,CAAC,WAAW,CAAC,GAAG;YAAE,MAAM,EAAE,mBAAmB,CAAA;SAAE;KACzE;CACF,GACG;KACG,WAAW,IAAI,MAAM,QAAQ,GAAG;SAC9B,MAAM,IAAI,MAAM,QAAQ,CAAC,WAAW,CAAC,GAAG,IAAI,CAC3C,QAAQ,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,EAC7B,UAAU,CAAC,MAAM,QAAQ,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAC,CACtE;KACF;CACF,GACD,KAAK,CAAC;AAEV,KAAK,UAAU,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC"}

package/dist/qraftAPIClient.js

@@ -0,0 +1,22 @@
+import { createCallbackProxyDecoration } from './lib/createCallbackProxyDecoration.js';
+export const qraftAPIClient = (services, callbacks, options) => {
+    return createCallbackProxyDecoration(Object.keys(callbacks), (path, functionName, args) => {
+        const serviceOperation = getByPath(services, path);
+        if (!isServiceOperation(serviceOperation))
+            throw new Error(`Service operation not found: ${path.join('.')}`);
+        if (functionName in callbacks) {
+            return callbacks[functionName](options, serviceOperation.schema, args);
+        }
+        throw new Error(`Not supported API method: ${String(functionName)}`);
+    });
+};
+function isServiceOperation(input) {
+    return input !== null && typeof input === 'object' && 'schema' in input;
+}
+function getByPath(obj, path) {
+    return path.reduce((acc, key) => {
+        if (acc && typeof acc === 'object' && key in acc)
+            return acc[key];
+    }, obj);
+}
+//# sourceMappingURL=qraftAPIClient.js.map

package/dist/qraftAPIClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"qraftAPIClient.js","sourceRoot":"","sources":["../src/qraftAPIClient.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,6BAA6B,EAAE,MAAM,wCAAwC,CAAC;AAQvF,MAAM,CAAC,MAAM,cAAc,GAAG,CAQ5B,QAMC,EACD,SAAoB,EACpB,OAA4B,EACwB,EAAE;IACtD,OAAO,6BAA6B,CAClC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,EACtB,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE;QAC3B,MAAM,gBAAgB,GAAG,SAAS,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QACnD,IAAI,CAAC,kBAAkB,CAAC,gBAAgB,CAAC;YACvC,MAAM,IAAI,KAAK,CAAC,gCAAgC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAEpE,IAAI,YAAY,IAAI,SAAS,EAAE,CAAC;YAC9B,OAAO,SAAS,CAAC,YAA+B,CAAC,CAC/C,OAAO,EACP,gBAAgB,CAAC,MAAM,EACvB,IAAI,CACL,CAAC;QACJ,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,6BAA6B,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;IACvE,CAAC,CACO,CAAC;AACb,CAAC,CAAC;AAEF,SAAS,kBAAkB,CACzB,KAAc;IAEd,OAAO,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,QAAQ,IAAI,KAAK,CAAC;AAC1E,CAAC;AAED,SAAS,SAAS,CAAC,GAA4B,EAAE,IAAc;IAC7D,OAAO,IAAI,CAAC,MAAM,CAAU,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;QACvC,IAAI,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,IAAI,GAAG;YAC9C,OAAO,GAAG,CAAC,GAAuB,CAAC,CAAC;IACxC,CAAC,EAAE,GAAG,CAAC,CAAC;AACV,CAAC"}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@openapi-qraft/react",
+  "version": "1.0.0-beta.0",
+  "description": "API client for React, providing type-safe requests and dynamic Tanstack Query React Hooks via a modular, Proxy-based architecture.",
+  "scripts": {
+    "build": "rimraf dist/ && tsc --project tsconfig.build.json",
+    "dev": "rimraf dist/ && tsc --project tsconfig.dev.json --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "generate-qraft": "openapi-qraft ./src/fixtures/openapi.json --clean -o src/fixtures/api --openapi-types-import-path '../../openapi.js' --explicit-import-extensions",
+    "generate-types": "openapi-qraft-typescript ./src/fixtures/openapi.json -o src/fixtures/openapi.ts"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "devDependencies": {
+    "@openapi-qraft/cli": "~1.0.0-beta.0",
+    "@openapi-qraft/openapi-typescript": "^1.0.0-beta.0",
+    "@tanstack/react-query": "^5.17.3",
+    "@testing-library/jest-dom": "^5.17.0",
+    "@testing-library/react": "^13.4.0",
+    "@testing-library/user-event": "^14.5.2",
+    "@types/react": "^18.2.47",
+    "@vitejs/plugin-react": "latest",
+    "@vitest/coverage-v8": "^1.1.3",
+    "jsdom": "latest",
+    "msw": "^2.0.12",
+    "query-string": "^8.1.0",
+    "react": "^18.2.0",
+    "rimraf": "^5.0.5",
+    "vitest": "^1.1.3"
+  },
+  "peerDependencies": {
+    "@tanstack/query-core": "^5.0.0",
+    "@tanstack/react-query": "^5.0.0",
+    "react": "^18.0.0"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!dist/fixtures/**",
+    "!src/fixtures/**"
+  ],
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./dist/index.js",
+    "./*": "./dist/*.js"
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "dist/*"
+      ]
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OpenAPI-Qraft/openapi-qraft.git",
+    "directory": "packages/react-client"
+  },
+  "bugs": {
+    "url": "https://github.com/OpenAPI-Qraft/openapi-qraft/issues"
+  },
+  "keywords": [
+    "openapi",
+    "swagger",
+    "rest",
+    "api",
+    "oapi_3",
+    "oapi_3_1",
+    "typescript",
+    "fetch",
+    "react",
+    "hooks",
+    "react-query"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/QraftContext.ts

@@ -0,0 +1,12 @@
+import { createContext } from 'react';
+
+import type { RequestClient } from './RequestClient.js';
+
+export type QraftContextValue =
+  | {
+      /** The request client to use for making requests. Will be invoked with every request. */
+      requestClient: RequestClient;
+    }
+  | undefined;
+
+export const QraftContext = createContext<QraftContextValue>(undefined);

package/src/RequestClient.ts

@@ -0,0 +1,32 @@
+export type RequestClient = <T>(
+  schema: RequestClientSchema,
+  options: RequestClientOptions
+) => Promise<T>;
+
+export type RequestClientSchema = {
+  url: string;
+  method:
+    | 'get'
+    | 'put'
+    | 'post'
+    | 'patch'
+    | 'delete'
+    | 'options'
+    | 'head'
+    | 'trace';
+  mediaType?: string;
+};
+
+export type RequestClientOptions = {
+  body?: BodyInit | Record<string, unknown> | null;
+  parameters?: RequestClientParams;
+  signal?: AbortSignal;
+  meta?: Record<string, unknown>;
+};
+
+export type RequestClientParams = {
+  header?: Record<string, any>;
+  path?: Record<string, any>;
+  query?: Record<string, any>;
+  cookie?: Record<string, any>;
+};

package/src/ServiceOperation.ts

@@ -0,0 +1,306 @@
+import {
+  DefaultError,
+  InfiniteData,
+  QueryClient,
+  InfiniteQueryPageParamsOptions,
+  NoInfer,
+  SetDataOptions,
+  Updater,
+} from '@tanstack/query-core';
+import type {
+  DefinedInitialDataInfiniteOptions,
+  DefinedInitialDataOptions,
+  DefinedUseInfiniteQueryResult,
+  DefinedUseQueryResult,
+  UndefinedInitialDataInfiniteOptions,
+  UndefinedInitialDataOptions,
+  UseInfiniteQueryResult,
+  UseMutationOptions,
+  UseMutationResult,
+  UseQueryResult,
+} from '@tanstack/react-query';
+
+export type ServiceOperationQueryKey<S extends { url: string }, T> = [
+  Pick<S, 'url'>,
+  T,
+];
+
+export type ServiceOperationInfiniteQueryKey<S extends { url: string }, T> = [
+  Pick<S, 'url'> & { infinite: true },
+  T,
+];
+
+export type ServiceOperationMutationKey<
+  S extends Record<'url' | 'method', string>,
+  T,
+> = [Pick<S, 'url' | 'method'>, T];
+
+export interface ServiceOperationQuery<
+  TSchema extends { url: string; method: string },
+  TData,
+  TParams,
+  TError = DefaultError,
+> extends ServiceOperationUseQuery<TSchema, TData, TParams, TError>,
+    ServiceOperationUseInfiniteQuery<TSchema, TData, TParams, TError>,
+    ServiceOperationQueryFn<TSchema, TData, TParams>,
+    ServiceOperationGetQueryData<TData, TParams>,
+    ServiceOperationGetInfiniteQueryData<TData, TParams>,
+    ServiceOperationSetQueryData<TData, TParams>,
+    ServiceOperationSetInfiniteQueryData<TData, TParams> {
+  schema: TSchema;
+}
+
+interface ServiceOperationUseQuery<
+  TSchema extends { url: string; method: string },
+  TData,
+  TParams = {},
+  TError = DefaultError,
+> {
+  getQueryKey<QueryKeyParams extends TParams>(
+    params: QueryKeyParams
+  ): ServiceOperationQueryKey<TSchema, QueryKeyParams>;
+
+  useQuery(
+    params: TParams,
+    options?: Omit<
+      UndefinedInitialDataOptions<
+        TData,
+        TError,
+        TData,
+        | ServiceOperationQueryKey<TSchema, TParams>
+        | readonly [...ServiceOperationQueryKey<TSchema, TParams>]
+      >,
+      'queryKey'
+    >,
+    queryClient?: QueryClient
+  ): UseQueryResult<TData, TError | Error>;
+  useQuery(
+    params: TParams,
+    options: Omit<
+      DefinedInitialDataOptions<
+        TData,
+        TError,
+        TData,
+        | ServiceOperationQueryKey<TSchema, TParams>
+        | readonly [...ServiceOperationQueryKey<TSchema, TParams>]
+      >,
+      'queryKey'
+    >,
+    queryClient?: QueryClient
+  ): DefinedUseQueryResult<TData, TError | Error>;
+}
+
+type PartialParams<T> = T extends object
+  ? { [K in keyof T]?: T[K] extends object ? Partial<T[K]> : T[K] }
+  : T;
+
+interface ServiceOperationUseInfiniteQuery<
+  TSchema extends { url: string; method: string },
+  TData,
+  TParams = {},
+  TError = DefaultError,
+> {
+  getInfiniteQueryKey<QueryKeyParams extends TParams>(
+    params: QueryKeyParams
+  ): ServiceOperationInfiniteQueryKey<TSchema, QueryKeyParams>;
+
+  useInfiniteQuery<TPageParam extends TParams>(
+    params: TParams,
+    options: Omit<
+      UndefinedInitialDataInfiniteOptions<
+        TData,
+        TError,
+        InfiniteData<TData>,
+        | ServiceOperationInfiniteQueryKey<TSchema, TParams>
+        | readonly [...ServiceOperationInfiniteQueryKey<TSchema, TParams>],
+        PartialParams<TPageParam>
+      >,
+      | 'queryKey'
+      | 'getPreviousPageParam'
+      | 'getNextPageParam'
+      | 'initialPageParam'
+    > &
+      InfiniteQueryPageParamsOptions<TData, PartialParams<TPageParam>>,
+    queryClient?: QueryClient
+  ): UseInfiniteQueryResult<InfiniteData<TData>, TError | Error>;
+  useInfiniteQuery<TPageParam extends TParams>(
+    params: TParams,
+    options: Omit<
+      DefinedInitialDataInfiniteOptions<
+        TData,
+        TError,
+        InfiniteData<TData>,
+        | ServiceOperationInfiniteQueryKey<TSchema, TParams>
+        | readonly [...ServiceOperationInfiniteQueryKey<TSchema, TParams>],
+        PartialParams<TPageParam>
+      >,
+      | 'queryKey'
+      | 'getPreviousPageParam'
+      | 'getNextPageParam'
+      | 'initialPageParam'
+    > &
+      InfiniteQueryPageParamsOptions<TData, PartialParams<TPageParam>>,
+    queryClient?: QueryClient
+  ): DefinedUseInfiniteQueryResult<InfiniteData<TData>, TError | Error>;
+}
+
+export interface ServiceOperationMutation<
+  TSchema extends { url: string; method: string },
+  TBody,
+  TData,
+  TParams,
+  TError = DefaultError,
+> extends ServiceOperationUseMutation<TSchema, TBody, TData, TParams, TError>,
+    ServiceOperationMutationFn<TSchema, TBody, TData, TParams>,
+    ServiceOperationSetQueryData<TData, TParams> {
+  schema: TSchema;
+}
+
+interface ServiceOperationUseMutation<
+  TSchema extends { url: string; method: string },
+  TBody,
+  TData,
+  TParams,
+  TError = DefaultError,
+> {
+  getMutationKey<T extends TParams>(
+    params: T
+  ): ServiceOperationMutationKey<TSchema, T>;
+
+  useMutation<
+    TVariables extends { body: TBody } & (NonNullable<TParams> extends never
+      ? {}
+      : TParams),
+    TContext = unknown,
+  >(
+    params?: undefined,
+    options?: Omit<
+      UseMutationOptions<TData, TError, TVariables, TContext>,
+      'mutationKey'
+    > & {
+      mutationKey?: ServiceOperationMutationKey<
+        TSchema,
+        NonNullable<TParams> extends never ? {} : TParams
+      >;
+    },
+    queryClient?: QueryClient
+  ): UseMutationResult<TData, TError | Error, TVariables, TContext>;
+
+  useMutation<TVariables extends TBody, TContext = unknown>(
+    params: TParams,
+    options?: Omit<
+      UseMutationOptions<TData, TError, TVariables, TContext>,
+      'mutationKey'
+    >,
+    queryClient?: QueryClient
+  ): UseMutationResult<TData, TError | Error, TVariables, TContext>;
+}
+
+interface ServiceOperationQueryFn<
+  TSchema extends { url: string; method: string },
+  TData,
+  TParams,
+> {
+  queryFn<
+    TMeta extends Record<string, any>,
+    TSignal extends AbortSignal = AbortSignal,
+  >(
+    options: { signal?: TSignal; meta?: TMeta } & (
+      | { queryKey: [unknown, TParams] }
+      | { parameters: TParams }
+    ),
+    client: (
+      schema: TSchema,
+      options: {
+        parameters: TParams;
+        signal?: TSignal;
+        meta?: TMeta;
+      }
+    ) => TData
+  ): TData;
+
+  queryFn<
+    TMeta extends Record<string, any>,
+    TSignal extends AbortSignal = AbortSignal,
+  >(
+    options: { signal?: TSignal; meta?: TMeta } & (
+      | { queryKey: [unknown, TParams] }
+      | { parameters: TParams }
+    ),
+    client: (
+      schema: TSchema,
+      options: {
+        parameters: TParams;
+        signal?: TSignal;
+        meta?: TMeta;
+      }
+    ) => Promise<TData>
+  ): Promise<TData>;
+}
+
+interface ServiceOperationSetQueryData<TData, TParams = {}> {
+  setQueryData(
+    queryKey: TParams,
+    updater: Updater<NoInfer<TData> | undefined, NoInfer<TData> | undefined>,
+    queryClient: QueryClient,
+    options?: SetDataOptions
+  ): TData | undefined;
+}
+
+interface ServiceOperationSetInfiniteQueryData<TData, TParams = {}> {
+  setInfiniteQueryData(
+    queryKey: TParams,
+    updater: Updater<
+      NoInfer<InfiniteData<TData>> | undefined,
+      NoInfer<InfiniteData<TData>> | undefined
+    >,
+    queryClient: QueryClient,
+    options?: SetDataOptions
+  ): InfiniteData<TData> | undefined;
+}
+
+interface ServiceOperationGetQueryData<TData, TParams = {}> {
+  getQueryData(queryKey: TParams, queryClient: QueryClient): TData | undefined;
+}
+
+interface ServiceOperationGetInfiniteQueryData<TData, TParams = {}> {
+  getInfiniteQueryData(
+    queryKey: TParams,
+    queryClient: QueryClient
+  ): InfiniteData<TData> | undefined;
+}
+
+export interface ServiceOperationMutationFn<
+  TSchema extends { url: string; method: string },
+  TBody,
+  TData,
+  TParams,
+> {
+  mutationFn(
+    client: (
+      schema: TSchema,
+      options: {
+        parameters: TParams;
+        body: TBody;
+      }
+    ) => TData,
+    options: {
+      parameters: TParams;
+      body: TBody;
+    }
+  ): TData;
+
+  mutationFn(
+    client: (
+      schema: TSchema,
+      options: {
+        parameters: TParams;
+        body: TBody;
+      }
+    ) => Promise<TData>,
+    options: {
+      parameters: TParams;
+      body: TBody;
+    }
+  ): Promise<TData>;
+}

package/src/callbacks/getInfiniteQueryData.ts

@@ -0,0 +1,26 @@
+import { InfiniteData } from '@tanstack/query-core';
+
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import type { RequestClientSchema } from '../RequestClient.js';
+import {
+  ServiceOperationInfiniteQueryKey,
+  ServiceOperationQuery,
+} from '../ServiceOperation.js';
+
+export function getInfiniteQueryData<TData>(
+  qraftOptions: QraftClientOptions | undefined,
+  schema: RequestClientSchema,
+  args: Parameters<
+    ServiceOperationQuery<
+      RequestClientSchema,
+      unknown,
+      TData
+    >['getInfiniteQueryData']
+  >
+): InfiniteData<TData> | undefined {
+  const [params, queryClient] = args;
+  return queryClient.getQueryData([
+    { url: schema.url, infinite: true },
+    params,
+  ] satisfies ServiceOperationInfiniteQueryKey<RequestClientSchema, unknown>);
+}

package/src/callbacks/getInfiniteQueryKey.ts

@@ -0,0 +1,23 @@
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import type { RequestClientSchema } from '../RequestClient.js';
+import {
+  ServiceOperationInfiniteQueryKey,
+  ServiceOperationQuery,
+} from '../ServiceOperation.js';
+
+export const getInfiniteQueryKey = (
+  qraftOptions: QraftClientOptions | undefined,
+  schema: RequestClientSchema,
+  args: Parameters<
+    ServiceOperationQuery<
+      RequestClientSchema,
+      unknown,
+      unknown
+    >['getInfiniteQueryKey']
+  >
+) => {
+  return [
+    { url: schema.url, infinite: true },
+    args[0],
+  ] satisfies ServiceOperationInfiniteQueryKey<RequestClientSchema, unknown>;
+};

package/src/callbacks/getMutationKey.ts

@@ -0,0 +1,47 @@
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import type { RequestClientSchema } from '../RequestClient.js';
+import {
+  ServiceOperationMutation,
+  ServiceOperationMutationKey,
+} from '../ServiceOperation.js';
+
+export const getMutationKey = (
+  qraftOptions: QraftClientOptions | undefined,
+  schema: RequestClientSchema,
+  args: unknown
+) => {
+  const [parameters] = args as Parameters<
+    ServiceOperationMutation<
+      RequestClientSchema,
+      unknown,
+      unknown,
+      unknown
+    >['getMutationKey']
+  >;
+
+  const key: ServiceOperationMutationKey<RequestClientSchema, unknown> = [
+    {
+      url: schema.url,
+      method: schema.method,
+    },
+    omitMutationPayload(parameters),
+  ];
+
+  return key;
+};
+
+function omitMutationPayload<T>(params: T) {
+  if (!params || typeof params !== 'object')
+    throw new Error('`params` must be object');
+
+  if ('body' in params || 'requestBody' in params) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { body, requestBody, ...paramsRest } = params as Record<
+      'body' | 'requestBody',
+      unknown
+    >;
+    return paramsRest;
+  }
+
+  return params as Omit<T, 'body' | 'requestBody'>;
+}

package/src/callbacks/getQueryData.ts

@@ -0,0 +1,20 @@
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import type { RequestClientSchema } from '../RequestClient.js';
+import {
+  ServiceOperationQuery,
+  ServiceOperationQueryKey,
+} from '../ServiceOperation.js';
+
+export function getQueryData<TData>(
+  qraftOptions: QraftClientOptions | undefined,
+  schema: RequestClientSchema,
+  args: Parameters<
+    ServiceOperationQuery<RequestClientSchema, unknown, TData>['getQueryData']
+  >
+): TData | undefined {
+  const [params, queryClient] = args;
+  return queryClient.getQueryData([
+    { url: schema.url },
+    params,
+  ] satisfies ServiceOperationQueryKey<RequestClientSchema, unknown>);
+}

package/src/callbacks/getQueryKey.ts

@@ -0,0 +1,19 @@
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import type { RequestClientSchema } from '../RequestClient.js';
+import {
+  ServiceOperationQuery,
+  ServiceOperationQueryKey,
+} from '../ServiceOperation.js';
+
+export const getQueryKey = (
+  qraftOptions: QraftClientOptions | undefined,
+  schema: RequestClientSchema,
+  args: Parameters<
+    ServiceOperationQuery<RequestClientSchema, unknown, unknown>['getQueryKey']
+  >
+) => {
+  return [{ url: schema.url }, args[0]] satisfies ServiceOperationQueryKey<
+    RequestClientSchema,
+    unknown
+  >;
+};

package/src/callbacks/mutationFn.ts

@@ -0,0 +1,22 @@
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import type { RequestClientSchema } from '../RequestClient.js';
+import { ServiceOperationMutation } from '../ServiceOperation.js';
+
+export const mutationFn = (
+  qraftOptions: QraftClientOptions | undefined,
+  schema: RequestClientSchema,
+  args: unknown
+) => {
+  const [client, options] = args as Parameters<
+    ServiceOperationMutation<
+      RequestClientSchema,
+      unknown,
+      unknown,
+      never
+    >['mutationFn']
+  >;
+  return client(schema, {
+    parameters: options.parameters,
+    body: options.body,
+  });
+};

package/src/callbacks/queryFn.ts

@@ -0,0 +1,21 @@
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import type { RequestClientSchema } from '../RequestClient.js';
+import { ServiceOperationQuery } from '../ServiceOperation.js';
+
+export const queryFn = (
+  qraftOptions: QraftClientOptions | undefined,
+  schema: RequestClientSchema,
+  args: Parameters<
+    ServiceOperationQuery<RequestClientSchema, unknown, never>['queryFn']
+  >
+) => {
+  const [options, client] = args;
+  const parameters =
+    'queryKey' in options ? options.queryKey[1] : options.parameters;
+
+  return client(schema, {
+    parameters,
+    meta: options.meta,
+    signal: options.signal,
+  });
+};