drizzle-graphql-suite 0.5.0

package/packages/query/dist/index.js

@@ -0,0 +1,172 @@
+// src/provider.tsx
+import { createContext, useContext } from "react";
+import { jsxDEV } from "react/jsx-dev-runtime";
+"use client";
+var GraphQLClientContext = createContext(null);
+function GraphQLProvider({
+  client,
+  children
+}) {
+  return /* @__PURE__ */ jsxDEV(GraphQLClientContext.Provider, {
+    value: client,
+    children
+  }, undefined, false, undefined, this);
+}
+function useGraphQLClient() {
+  const client = useContext(GraphQLClientContext);
+  if (!client) {
+    throw new Error("useGraphQLClient must be used within a <GraphQLProvider>");
+  }
+  return client;
+}
+// src/useEntity.ts
+import { useMemo } from "react";
+function useEntity(entityName) {
+  const client = useGraphQLClient();
+  return useMemo(() => client.entity(entityName), [client, entityName]);
+}
+// src/useEntityInfiniteQuery.ts
+import { useInfiniteQuery } from "@tanstack/react-query";
+function useEntityInfiniteQuery(entity, params, options) {
+  const queryKey = options?.queryKey ?? [
+    "gql",
+    "infinite",
+    params.select,
+    params.where,
+    params.orderBy,
+    params.pageSize
+  ];
+  return useInfiniteQuery({
+    queryKey,
+    initialPageParam: 0,
+    queryFn: async ({ pageParam = 0 }) => {
+      const queryParams = {
+        ...params,
+        limit: params.pageSize,
+        offset: pageParam * params.pageSize
+      };
+      const items = await entity.query(queryParams);
+      const count = await entity.count({ where: params.where });
+      return {
+        items,
+        count
+      };
+    },
+    getNextPageParam: (lastPage, allPages) => {
+      const totalFetched = allPages.length * params.pageSize;
+      return totalFetched < lastPage.count ? allPages.length : undefined;
+    },
+    enabled: options?.enabled,
+    gcTime: options?.gcTime,
+    staleTime: options?.staleTime
+  });
+}
+// src/useEntityList.ts
+import { useQuery } from "@tanstack/react-query";
+function useEntityList(entity, params, options) {
+  const queryKey = options?.queryKey ?? [
+    "gql",
+    "list",
+    params.select,
+    params.where,
+    params.orderBy,
+    params.limit,
+    params.offset
+  ];
+  return useQuery({
+    queryKey,
+    queryFn: async () => {
+      return await entity.query(params);
+    },
+    enabled: options?.enabled,
+    gcTime: options?.gcTime,
+    staleTime: options?.staleTime,
+    refetchOnWindowFocus: options?.refetchOnWindowFocus
+  });
+}
+// src/useEntityMutation.ts
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+function useEntityInsert(entity, returning, options) {
+  const queryClient = useQueryClient();
+  const shouldInvalidate = options?.invalidate !== false;
+  return useMutation({
+    mutationFn: async (params) => {
+      return await entity.insert({ ...params, returning });
+    },
+    onSuccess: (data) => {
+      if (shouldInvalidate) {
+        const key = options?.invalidateKey ?? ["gql"];
+        queryClient.invalidateQueries({ queryKey: key });
+      }
+      options?.onSuccess?.(data);
+    },
+    onError: options?.onError
+  });
+}
+function useEntityUpdate(entity, returning, options) {
+  const queryClient = useQueryClient();
+  const shouldInvalidate = options?.invalidate !== false;
+  return useMutation({
+    mutationFn: async (params) => {
+      return await entity.update({ ...params, returning });
+    },
+    onSuccess: (data) => {
+      if (shouldInvalidate) {
+        const key = options?.invalidateKey ?? ["gql"];
+        queryClient.invalidateQueries({ queryKey: key });
+      }
+      options?.onSuccess?.(data);
+    },
+    onError: options?.onError
+  });
+}
+function useEntityDelete(entity, returning, options) {
+  const queryClient = useQueryClient();
+  const shouldInvalidate = options?.invalidate !== false;
+  return useMutation({
+    mutationFn: async (params) => {
+      return await entity.delete({ ...params, returning });
+    },
+    onSuccess: (data) => {
+      if (shouldInvalidate) {
+        const key = options?.invalidateKey ?? ["gql"];
+        queryClient.invalidateQueries({ queryKey: key });
+      }
+      options?.onSuccess?.(data);
+    },
+    onError: options?.onError
+  });
+}
+// src/useEntityQuery.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+function useEntityQuery(entity, params, options) {
+  const queryKey = options?.queryKey ?? [
+    "gql",
+    "single",
+    params.select,
+    params.where,
+    params.orderBy,
+    params.offset
+  ];
+  return useQuery2({
+    queryKey,
+    queryFn: async () => {
+      return await entity.querySingle(params);
+    },
+    enabled: options?.enabled,
+    gcTime: options?.gcTime,
+    staleTime: options?.staleTime,
+    refetchOnWindowFocus: options?.refetchOnWindowFocus
+  });
+}
+export {
+  useGraphQLClient,
+  useEntityUpdate,
+  useEntityQuery,
+  useEntityList,
+  useEntityInsert,
+  useEntityInfiniteQuery,
+  useEntityDelete,
+  useEntity,
+  GraphQLProvider
+};

package/packages/query/dist/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@drizzle-graphql-suite/query",
+  "version": "0.5.0",
+  "description": "React Query hooks for the Drizzle GraphQL client with caching and automatic invalidation",
+  "license": "MIT",
+  "author": "https://github.com/dmythro",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/annexare/drizzle-graphql-suite.git",
+    "directory": "packages/query"
+  },
+  "homepage": "https://github.com/annexare/drizzle-graphql-suite/tree/main/packages/query#readme",
+  "keywords": [
+    "drizzle",
+    "graphql",
+    "react",
+    "react-query",
+    "tanstack",
+    "hooks",
+    "typescript"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    }
+  },
+  "peerDependencies": {
+    "@drizzle-graphql-suite/client": ">=0.5.0",
+    "@tanstack/react-query": ">=5.0.0",
+    "react": ">=18.0.0"
+  }
+}

package/packages/query/dist/provider.d.ts

@@ -0,0 +1,7 @@
+import type { AnyEntityDefs, GraphQLClient, SchemaDescriptor } from '@drizzle-graphql-suite/client';
+import { type ReactNode } from 'react';
+export declare function GraphQLProvider<TSchema extends SchemaDescriptor, TDefs extends AnyEntityDefs>({ client, children, }: {
+    client: GraphQLClient<TSchema, TDefs>;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useGraphQLClient<TSchema extends SchemaDescriptor = SchemaDescriptor, TDefs extends AnyEntityDefs = AnyEntityDefs>(): GraphQLClient<TSchema, TDefs>;

package/packages/query/dist/test-setup.d.ts

@@ -0,0 +1 @@
+export {};

package/packages/query/dist/test-utils.d.ts

@@ -0,0 +1,40 @@
+import './test-setup';
+import { QueryClient } from '@tanstack/react-query';
+import { type ReactNode } from 'react';
+type RenderHookOptions = {
+    wrapper?: (props: {
+        children: ReactNode;
+    }) => ReactNode;
+};
+type RenderHookResult<T> = {
+    result: {
+        current: T;
+    };
+    rerender: () => void;
+    unmount: () => void;
+};
+export declare function renderHook<T>(callback: () => T, options?: RenderHookOptions): RenderHookResult<T>;
+export declare function renderHookAsync<T>(callback: () => T, options?: RenderHookOptions): Promise<RenderHookResult<T>>;
+type MockParams = any;
+export declare function createMockEntityClient(): {
+    query: import("bun:test").Mock<(p: MockParams) => Promise<Record<string, unknown>[]>>;
+    querySingle: import("bun:test").Mock<(p: MockParams) => Promise<Record<string, unknown> | null>>;
+    count: import("bun:test").Mock<(p: MockParams) => Promise<number>>;
+    insert: import("bun:test").Mock<(p: MockParams) => Promise<Record<string, unknown>[]>>;
+    insertSingle: import("bun:test").Mock<(p: MockParams) => Promise<Record<string, unknown> | null>>;
+    update: import("bun:test").Mock<(p: MockParams) => Promise<Record<string, unknown>[]>>;
+    delete: import("bun:test").Mock<(p: MockParams) => Promise<Record<string, unknown>[]>>;
+};
+export declare function createMockGraphQLClient(entityClient?: any): {
+    entity: import("bun:test").Mock<(name: string) => any>;
+    url: string;
+    schema: {};
+    execute: import("bun:test").Mock<() => Promise<{
+        data: {};
+    }>>;
+};
+export declare function createTestQueryClient(): QueryClient;
+export declare function createWrapper(mockClient: any, queryClient?: QueryClient): ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};

package/packages/query/dist/types.d.ts

@@ -0,0 +1,4 @@
+import type { AnyEntityDefs, GraphQLClient, SchemaDescriptor } from '@drizzle-graphql-suite/client';
+export type GraphQLClientContext<TSchema extends SchemaDescriptor = SchemaDescriptor, TDefs extends AnyEntityDefs = AnyEntityDefs> = {
+    client: GraphQLClient<TSchema, TDefs>;
+};

package/packages/query/dist/useEntity.d.ts

@@ -0,0 +1,2 @@
+import type { AnyEntityDefs, EntityClient, EntityDef, SchemaDescriptor } from '@drizzle-graphql-suite/client';
+export declare function useEntity<TSchema extends SchemaDescriptor, TDefs extends AnyEntityDefs, TEntityName extends string & keyof TSchema>(entityName: TEntityName): TEntityName extends keyof TDefs ? EntityClient<TDefs, TDefs[TEntityName] & EntityDef> : EntityClient<TDefs, EntityDef>;

package/packages/query/dist/useEntityInfiniteQuery.d.ts

@@ -0,0 +1,26 @@
+import type { AnyEntityDefs, EntityClient, EntityDef, InferResult } from '@drizzle-graphql-suite/client';
+import { type UseInfiniteQueryResult } from '@tanstack/react-query';
+type EntityInfiniteParams<TEntity extends EntityDef, TSelect extends Record<string, unknown>> = {
+    select: TSelect;
+    where?: TEntity extends {
+        filters: infer F;
+    } ? F : never;
+    pageSize: number;
+    orderBy?: TEntity extends {
+        orderBy: infer O;
+    } ? O : never;
+};
+type EntityInfiniteOptions = {
+    enabled?: boolean;
+    gcTime?: number;
+    staleTime?: number;
+    queryKey?: unknown[];
+};
+type PageData<T> = {
+    items: T[];
+    count: number;
+};
+export declare function useEntityInfiniteQuery<TDefs extends AnyEntityDefs, TEntity extends EntityDef, TSelect extends Record<string, unknown>>(entity: EntityClient<TDefs, TEntity>, params: EntityInfiniteParams<TEntity, TSelect>, options?: EntityInfiniteOptions): UseInfiniteQueryResult<{
+    pages: PageData<InferResult<TDefs, TEntity, TSelect>>[];
+}>;
+export {};

package/packages/query/dist/useEntityList.d.ts

@@ -0,0 +1,22 @@
+import type { AnyEntityDefs, EntityClient, EntityDef, InferResult } from '@drizzle-graphql-suite/client';
+import { type UseQueryResult } from '@tanstack/react-query';
+type EntityListParams<TEntity extends EntityDef, TSelect extends Record<string, unknown>> = {
+    select: TSelect;
+    where?: TEntity extends {
+        filters: infer F;
+    } ? F : never;
+    limit?: number;
+    offset?: number;
+    orderBy?: TEntity extends {
+        orderBy: infer O;
+    } ? O : never;
+};
+type EntityListOptions = {
+    enabled?: boolean;
+    gcTime?: number;
+    staleTime?: number;
+    refetchOnWindowFocus?: boolean;
+    queryKey?: unknown[];
+};
+export declare function useEntityList<TDefs extends AnyEntityDefs, TEntity extends EntityDef, TSelect extends Record<string, unknown>>(entity: EntityClient<TDefs, TEntity>, params: EntityListParams<TEntity, TSelect>, options?: EntityListOptions): UseQueryResult<InferResult<TDefs, TEntity, TSelect>[]>;
+export {};

package/packages/query/dist/useEntityMutation.d.ts

@@ -0,0 +1,41 @@
+import type { AnyEntityDefs, EntityClient, EntityDef, InferResult } from '@drizzle-graphql-suite/client';
+import { type UseMutationResult } from '@tanstack/react-query';
+type InsertOptions<TResult> = {
+    invalidate?: boolean;
+    invalidateKey?: unknown[];
+    onSuccess?: (data: TResult) => void;
+    onError?: (error: Error) => void;
+};
+export declare function useEntityInsert<TDefs extends AnyEntityDefs, TEntity extends EntityDef, TSelect extends Record<string, unknown>>(entity: EntityClient<TDefs, TEntity>, returning?: TSelect, options?: InsertOptions<InferResult<TDefs, TEntity, TSelect>[]>): UseMutationResult<InferResult<TDefs, TEntity, TSelect>[], Error, {
+    values: TEntity extends {
+        insertInput: infer I;
+    } ? I[] : never;
+}>;
+type UpdateParams<TEntity extends EntityDef> = {
+    set: TEntity extends {
+        updateInput: infer U;
+    } ? U : never;
+    where?: TEntity extends {
+        filters: infer F;
+    } ? F : never;
+};
+type UpdateOptions<TResult> = {
+    invalidate?: boolean;
+    invalidateKey?: unknown[];
+    onSuccess?: (data: TResult) => void;
+    onError?: (error: Error) => void;
+};
+export declare function useEntityUpdate<TDefs extends AnyEntityDefs, TEntity extends EntityDef, TSelect extends Record<string, unknown>>(entity: EntityClient<TDefs, TEntity>, returning?: TSelect, options?: UpdateOptions<InferResult<TDefs, TEntity, TSelect>[]>): UseMutationResult<InferResult<TDefs, TEntity, TSelect>[], Error, UpdateParams<TEntity>>;
+type DeleteParams<TEntity extends EntityDef> = {
+    where?: TEntity extends {
+        filters: infer F;
+    } ? F : never;
+};
+type DeleteOptions<TResult> = {
+    invalidate?: boolean;
+    invalidateKey?: unknown[];
+    onSuccess?: (data: TResult) => void;
+    onError?: (error: Error) => void;
+};
+export declare function useEntityDelete<TDefs extends AnyEntityDefs, TEntity extends EntityDef, TSelect extends Record<string, unknown>>(entity: EntityClient<TDefs, TEntity>, returning?: TSelect, options?: DeleteOptions<InferResult<TDefs, TEntity, TSelect>[]>): UseMutationResult<InferResult<TDefs, TEntity, TSelect>[], Error, DeleteParams<TEntity>>;
+export {};

package/packages/query/dist/useEntityQuery.d.ts

@@ -0,0 +1,21 @@
+import type { AnyEntityDefs, EntityClient, EntityDef, InferResult } from '@drizzle-graphql-suite/client';
+import { type UseQueryResult } from '@tanstack/react-query';
+type EntityQueryParams<TEntity extends EntityDef, TSelect extends Record<string, unknown>> = {
+    select: TSelect;
+    where?: TEntity extends {
+        filters: infer F;
+    } ? F : never;
+    offset?: number;
+    orderBy?: TEntity extends {
+        orderBy: infer O;
+    } ? O : never;
+};
+type EntityQueryOptions = {
+    enabled?: boolean;
+    gcTime?: number;
+    staleTime?: number;
+    refetchOnWindowFocus?: boolean;
+    queryKey?: unknown[];
+};
+export declare function useEntityQuery<TDefs extends AnyEntityDefs, TEntity extends EntityDef, TSelect extends Record<string, unknown>>(entity: EntityClient<TDefs, TEntity>, params: EntityQueryParams<TEntity, TSelect>, options?: EntityQueryOptions): UseQueryResult<InferResult<TDefs, TEntity, TSelect> | null>;
+export {};