@openapi-qraft/react 1.0.0-beta.0

package/src/callbacks/setInfiniteQueryData.ts

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

package/src/callbacks/setQueryData.ts

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

package/src/callbacks/shelfMerge.test.ts

@@ -0,0 +1,94 @@
+import { shelfMerge } from './useInfiniteQuery.js';
+
+describe('shelfMerge', () => {
+  it('merges simple objects', async () => {
+    expect(shelfMerge(1, { path: 1 }, { query: 2 }, { header: 3 })).toEqual({
+      path: 1,
+      query: 2,
+      header: 3,
+    });
+  });
+
+  it('merges simple objects with overlapping', async () => {
+    expect(
+      shelfMerge(2, { path: 1 }, { path: { id: 22 } }, { header: 3 })
+    ).toEqual({
+      path: { id: 22 },
+      header: 3,
+    });
+  });
+
+  it('merges objects with overlapping in child objects', async () => {
+    expect(
+      shelfMerge(
+        2,
+        { query: { id: 11, page: 22 } },
+        { query: { id: 44, limit: 33 } },
+        { header: 3 }
+      )
+    ).toEqual({
+      query: { id: 44, page: 22, limit: 33 },
+      header: 3,
+    });
+  });
+
+  it('merges objects with overlapping in child objects on specific depth (1)', async () => {
+    expect(
+      shelfMerge(
+        1,
+        { query: { id: 11, page: 22 } },
+        { query: { id: 44, limit: 33 } },
+        { header: 3 }
+      )
+    ).toEqual({
+      query: { id: 44, limit: 33 },
+      header: 3,
+    });
+  });
+
+  it('merges objects with overlapping in child objects on specific depth (2)', async () => {
+    expect(
+      shelfMerge(
+        2,
+        { query: { id: 11, page: 22 } },
+        { query: { id: 44, limit: 33 } },
+        { header: 3 }
+      )
+    ).toEqual({
+      query: { id: 44, limit: 33, page: 22 },
+      header: 3,
+    });
+  });
+
+  it('merges arrays without nesting', async () => {
+    expect(
+      shelfMerge(
+        2,
+        { query: [{ id: 11, page: 22 }] },
+        { query: [{ id: 44, limit: 33 }] },
+        { header: 3 }
+      )
+    ).toEqual({
+      query: [{ id: 44, limit: 33 }],
+      header: 3,
+    });
+  });
+
+  it('merges objects with overlapping in child objects and depth', async () => {
+    expect(
+      shelfMerge(
+        3,
+        { query: { one: { id: 11, page: 22 }, two: { ids: [55] } } },
+        { query: { one: { id: 44, limit: 33 }, three: { filter: 66 } } },
+        { header: 3 }
+      )
+    ).toEqual({
+      query: {
+        one: { id: 44, page: 22, limit: 33 },
+        two: { ids: [55] },
+        three: { filter: 66 },
+      },
+      header: 3,
+    });
+  });
+});

package/src/callbacks/useInfiniteQuery.ts

@@ -0,0 +1,88 @@
+import { useContext } from 'react';
+
+import type { DefaultError, InfiniteData } from '@tanstack/query-core';
+import {
+  useInfiniteQuery as useInfiniteQueryBase,
+  UseInfiniteQueryResult,
+} from '@tanstack/react-query';
+
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import { QraftContext } from '../QraftContext.js';
+import type { RequestClientSchema } from '../RequestClient.js';
+import { ServiceOperationQuery } from '../ServiceOperation.js';
+
+export const useInfiniteQuery: <
+  TQueryFnData,
+  TError = DefaultError,
+  TData = InfiniteData<TQueryFnData>,
+>(
+  qraftOptions: QraftClientOptions | undefined,
+  schema: RequestClientSchema,
+  args: Parameters<
+    ServiceOperationQuery<
+      RequestClientSchema,
+      unknown,
+      unknown
+    >['useInfiniteQuery']
+  >
+) => UseInfiniteQueryResult<TData, TError> = (qraftOptions, schema, args) => {
+  const [params, options, ...restArgs] = args;
+
+  const requestClient = useContext(qraftOptions?.context ?? QraftContext)
+    ?.requestClient;
+
+  if (!requestClient) throw new Error(`QraftContext.requestClient not found`);
+
+  return useInfiniteQueryBase(
+    {
+      ...options,
+      queryKey: [{ url: schema.url, infinite: true }, params as never] as const,
+      queryFn:
+        options?.queryFn ??
+        function ({ queryKey: [, queryParams], signal, meta, pageParam }) {
+          return requestClient(schema, {
+            parameters: shelfMerge(2, queryParams, pageParam) as never,
+            signal,
+            meta,
+          });
+        },
+    },
+    ...restArgs
+  ) as never;
+};
+
+/**
+ * Merges objects with provided depth
+ * @param depth
+ * @param args
+ */
+export function shelfMerge<T>(depth = 2, ...args: T[]): T {
+  return args.reduce((acc, arg) => {
+    if (!arg || typeof arg !== 'object') return acc;
+
+    Object.entries(arg).forEach(([key, value]) => {
+      if (typeof value !== 'object') {
+        acc[key as never] = value as never;
+        return;
+      }
+
+      if (Array.isArray(value)) {
+        acc[key as never] = value as never;
+        return;
+      }
+
+      if (depth > 1) {
+        acc[key as never] = shelfMerge(
+          depth - 1,
+          acc[key as never],
+          value
+        ) as never;
+        return;
+      }
+
+      acc[key as never] = value as never;
+    });
+
+    return acc;
+  }, {} as T);
+}

package/src/callbacks/useMutation.ts

@@ -0,0 +1,100 @@
+import { useContext } from 'react';
+
+import type { DefaultError } from '@tanstack/query-core';
+import type { UseMutationResult } from '@tanstack/react-query';
+import { useMutation as useMutationBase } from '@tanstack/react-query';
+
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import { QraftContext } from '../QraftContext.js';
+import type { RequestClientSchema } from '../RequestClient.js';
+import {
+  ServiceOperationMutation,
+  ServiceOperationMutationKey,
+} from '../ServiceOperation.js';
+
+export const useMutation: <
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = void,
+  TContext = unknown,
+>(
+  qraftOptions: QraftClientOptions | undefined,
+  schema: RequestClientSchema,
+  args: Parameters<
+    ServiceOperationMutation<
+      RequestClientSchema,
+      object | undefined,
+      TVariables,
+      TData
+    >['useMutation']
+  >
+) => UseMutationResult<TData, TError, TVariables, TContext> = (
+  qraftOptions,
+  schema,
+  args
+) => {
+  const [parameters, options, ...restArgs] = args;
+
+  if (
+    parameters &&
+    typeof parameters === 'object' &&
+    options &&
+    'mutationKey' in options
+  )
+    throw new Error(
+      `'useMutation': parameters and 'options.mutationKey' cannot be used together`
+    );
+
+  const requestClient = useContext(qraftOptions?.context ?? QraftContext)
+    ?.requestClient;
+
+  if (!requestClient) throw new Error(`QraftContext.requestClient not found`);
+
+  const mutationKey =
+    parameters && typeof parameters === 'object'
+      ? ([
+          {
+            url: schema.url,
+            method: schema.method,
+          },
+          parameters,
+        ] as const)
+      : options && 'mutationKey' in options
+        ? (options.mutationKey as ServiceOperationMutationKey<
+            typeof schema,
+            unknown
+          >)
+        : ([
+            {
+              url: schema.url,
+              method: schema.method,
+            },
+          ] as const);
+
+  return useMutationBase(
+    {
+      ...options,
+      mutationKey,
+      mutationFn:
+        options?.mutationFn ??
+        (parameters
+          ? function (bodyPayload) {
+              return requestClient(schema, {
+                parameters,
+                body: bodyPayload as never,
+              });
+            }
+          : function (parametersAndBodyPayload) {
+              const { body, ...parameters } = parametersAndBodyPayload as {
+                body: unknown;
+              };
+
+              return requestClient(schema, {
+                body,
+                parameters,
+              } as never);
+            }),
+    },
+    ...restArgs
+  ) as never;
+};

package/src/callbacks/useQuery.ts

@@ -0,0 +1,56 @@
+import { useContext } from 'react';
+
+import type { DefaultError } from '@tanstack/query-core';
+import type { UseQueryResult } from '@tanstack/react-query';
+import { useQuery as useQueryBase } from '@tanstack/react-query';
+
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import { QraftContext } from '../QraftContext.js';
+import type { RequestClientSchema } from '../RequestClient.js';
+import {
+  ServiceOperationQuery,
+  ServiceOperationQueryKey,
+} from '../ServiceOperation.js';
+
+export const useQuery: <
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+>(
+  qraftOptions: QraftClientOptions | undefined,
+  schema: RequestClientSchema,
+  args: Parameters<
+    ServiceOperationQuery<RequestClientSchema, unknown, unknown>['useQuery']
+  >
+) => UseQueryResult<TData, TError> & {
+  queryKey: ServiceOperationQueryKey<RequestClientSchema, unknown>;
+} = (qraftOptions, schema, args) => {
+  const [params, options, ...restArgs] = args;
+
+  const requestClient = useContext(qraftOptions?.context ?? QraftContext)
+    ?.requestClient;
+
+  if (!requestClient) throw new Error(`QraftContext.requestClient not found`);
+
+  const queryKey: ServiceOperationQueryKey<RequestClientSchema, unknown> = [
+    { url: schema.url },
+    params,
+  ];
+
+  return useQueryBase(
+    {
+      ...options,
+      queryKey,
+      queryFn:
+        options?.queryFn ??
+        function ({ queryKey: [, queryParams], signal, meta }) {
+          return requestClient(schema, {
+            parameters: queryParams as never,
+            signal,
+            meta,
+          });
+        },
+    },
+    ...restArgs
+  ) as never;
+};

package/src/index.ts

@@ -0,0 +1,11 @@
+export { qraftAPIClient } from './qraftAPIClient.js';
+export type { QraftClientOptions } from './qraftAPIClient.js';
+export { QraftContext } from './QraftContext.js';
+export type { QraftContextValue } from './QraftContext.js';
+export { request, urlSerializer, bodySerializer } from './lib/request.js';
+export type { APIRequestInit, HeadersOptions } from './lib/request.js';
+export type {
+  ServiceOperationQuery,
+  ServiceOperationMutation,
+} from './ServiceOperation.js';
+export type { RequestClient } from './RequestClient.js';

package/src/lib/createCallbackProxyDecoration.ts

@@ -0,0 +1,34 @@
+import { createRecursiveProxy } from './createRecursiveProxy.js';
+
+/**
+ * Create proxy for decorating procedures
+ */
+export function createCallbackProxyDecoration<
+  Functions extends string[] | Readonly<string[]>,
+>(
+  functions: Functions,
+  callback: (
+    path: string[],
+    functionName: Functions[number],
+    args: unknown[]
+  ) => unknown
+) {
+  return createRecursiveProxy((opts) => {
+    const path = opts.path.slice(0, -1);
+
+    // The last arg is for instance `.useMutation` or `.useQuery()`
+    const functionName = opts.path[opts.path.length - 1];
+
+    if (functionName === '_def') {
+      return {
+        path: path,
+      };
+    }
+
+    if (!functions.includes(functionName)) {
+      throw new Error(`Function ${functionName} is not supported`);
+    }
+
+    return callback(path, functionName, opts.args);
+  }, []);
+}

package/src/lib/createRecursiveProxy.ts

@@ -0,0 +1,27 @@
+type ProxyCallback = (opts: { path: string[]; args: unknown[] }) => unknown;
+
+export function createRecursiveProxy(callback: ProxyCallback, path: string[]) {
+  const proxy: unknown = new Proxy(noop, {
+    get(_obj, key) {
+      if (typeof key !== 'string' || key === 'then') {
+        // special case for if the proxy is accidentally treated
+        // like a PromiseLike (like in `Promise.resolve(proxy)`)
+        return undefined;
+      }
+      return createRecursiveProxy(callback, [...path, key]);
+    },
+    apply(_1, _2, args) {
+      const isApply = path[path.length - 1] === 'apply';
+      return callback({
+        args: isApply ? (args.length >= 2 ? args[1] : []) : args,
+        path: isApply ? path.slice(0, -1) : path,
+      });
+    },
+  });
+
+  return proxy;
+}
+
+function noop() {
+  // noop
+}