@dokamerce/web-sdk 0.9.0

package/src/functions/init-sdk-client.function.ts

@@ -0,0 +1,19 @@
+import { setSdkClient } from "../contexts";
+import { GraphQLClient } from "graphql-request";
+
+interface InitSdkClientArgs {
+  base: string;
+  realm: string;
+  key: string;
+}
+
+export function initSdkClient({ base, realm, key }: InitSdkClientArgs) {
+  const client = new GraphQLClient(`${base}`, {
+    headers: {
+      "x-realm-key": realm,
+      "x-api-token": key,
+      "x-origin": "sdk",
+    },
+  });
+  setSdkClient(client);
+}

package/src/functions/init-sdk.function.ts

@@ -0,0 +1,26 @@
+import { getSdkStatus, setSdkStatus } from "../contexts";
+import { initSdkClient } from "./init-sdk-client.function";
+import { GRAPHQL_BASE_URL } from "../constants/graphql-base.constant";
+
+interface InitSdkArgs {
+  realm: string;
+  key: string;
+}
+
+export function initSdk({ realm, key }: InitSdkArgs) {
+  try {
+    if (getSdkStatus() !== "unknown") return;
+    setSdkStatus("initializing");
+
+    initSdkClient({
+      base: GRAPHQL_BASE_URL,
+      key,
+      realm,
+    });
+
+    setSdkStatus("ready");
+
+  } catch (error) {
+    setSdkStatus("fails");
+  }
+}

package/src/functions/safe-call.function.ts

@@ -0,0 +1,29 @@
+export type SDKError = {
+  code: string;
+  message: string;
+  details?: any;
+};
+
+export async function safeCall<T>({
+  fn,
+  onError,
+}: {
+  fn: () => Promise<T> | T;
+  onError?: (error: SDKError) => void;
+}): Promise<T | null> {
+  try {
+    return await fn();
+  } catch (err: unknown) {
+    // Normalize the error to SDKError
+    const sdkError: SDKError = {
+      code: (err as any)?.code || "UNKNOWN_ERROR",
+      message: (err as any)?.message || String(err),
+      details: (err as any)?.details,
+    };
+
+    if (onError) onError(sdkError);
+    else console.error("SDK Error:", sdkError);
+
+    return null;
+  }
+}

package/src/index.ts

@@ -0,0 +1,74 @@
+/**
+ * Dokamerce SDK Factory
+ *
+ * TODOs:
+ * [ ] Logger: implement structured logging for all SDK operations
+ * [ ] Cache Layer: add caching for queries (LRU / Redis / in-memory)
+ * [ ] Pagination & Helpers: add helpers for paginated & infinite queries
+ * [ ] Batch Requests: support batching multiple requests in a single call
+ * [ ] Subscriptions (Realtime): implement realtime updates via WebSockets / GraphQL subscriptions
+ * [ ] Docs & Examples: write usage documentation and code examples
+ * [ ] Testing & Mocking: add unit tests, integration tests, and mocks for SDK
+ * [ ] Rate Limiting / Retry: implement retry with exponential backoff on errors
+ */
+
+import { initSdk } from "./functions/init-sdk.function";
+import { safeCall, SDKError } from "./functions/safe-call.function";
+// import { ShopSDK } from "./typings/sdk.typing";
+import { createProductsSdk } from "./services/products";
+import { getSdkClient } from "./contexts";
+import { createSellersSdk, createColorsSdk, createFileUploadSdk, createCategoriesSdk, createBrandsSdk, createAttributesSdk, createCustomersSdk, createOrdersSdk } from "./services";
+import { createMetricsSdk } from "./services/metrics";
+import { DokamerceSDK } from "./typings/sdk.typing";
+
+export type SDKOptions = {
+  realm: string;
+  key: string;
+  onError?: (error: SDKError) => void;
+};
+
+/**
+ * Creates a Dokamerce SDK instance.
+ * 
+ * Current Status:
+ * ✅ Initialization with realm/key via initSdk
+ * ✅ Safe error handling with safeCall
+ * ⚠️ Client retrieval uses getSdkClient (may need refactor for backend safety)
+ * ✅ Products SDK attached
+ *
+ * TODO Improvements:
+ * - Ensure backend safety by creating per-instance GraphQLClient instead of relying on global context
+ * - Wrap all SDK methods with safeCall automatically
+ */
+export function createInstance(options: SDKOptions): DokamerceSDK {
+  // 1️⃣ Initialize SDK safely
+  safeCall({
+    fn: () =>
+      initSdk({
+        realm: options.realm,
+        key: options.key,
+      }),
+    onError: options.onError,
+  });
+
+  // 2️⃣ Retrieve GraphQL client (currently from global context)
+  const client = getSdkClient();
+
+  if (!client) {
+    throw new Error("Failed to initialize client");
+  }
+
+  // 3️⃣ Return SDK instance
+  return {
+    products: createProductsSdk(client),
+    sellers: createSellersSdk(client),
+    colors: createColorsSdk(client),
+    files: createFileUploadSdk(client),
+    categories: createCategoriesSdk(client),
+    brands: createBrandsSdk(client),
+    attributes: createAttributesSdk(client),
+    customers: createCustomersSdk(client),
+    orders: createOrdersSdk(client),
+    metrics: createMetricsSdk(client),
+  };
+}

package/src/services/attributes.ts

@@ -0,0 +1,42 @@
+import { GraphQLClient } from "graphql-request";
+import {
+  PaginatedAttributesDocument,
+  PaginatedAttributesQuery,
+  PaginatedAttributesQueryVariables,
+  InfiniteAttributesDocument,
+  InfiniteAttributesQuery,
+  InfiniteAttributesQueryVariables,
+} from "@dokamerce/graphql";
+import { fetchAllInfinite, InfiniteListSdk } from "@/utils/fetch-all-infinite.util";
+
+
+export interface AttributesSdk { 
+  // Paginated queries 
+  paginated: (variables?: PaginatedAttributesQueryVariables) => Promise<PaginatedAttributesQuery>; 
+  // Infinite queries 
+  infinite: (variables: InfiniteAttributesQueryVariables) => Promise<InfiniteAttributesQuery>; 
+  all: (variables: InfiniteAttributesQueryVariables) => Promise<InfiniteAttributesQuery["infiniteAttributes"]["edges"][number]["node"][]>; 
+}
+
+export function createAttributesSdk(client: GraphQLClient): AttributesSdk {
+ 
+  const paginated = {
+    paginated(variables: PaginatedAttributesQueryVariables = {}) {
+      return client.request<PaginatedAttributesQuery>(PaginatedAttributesDocument, variables);
+    },
+  };
+
+  const infinite = {
+    infinite(variables: InfiniteAttributesQueryVariables) {
+      return client.request<InfiniteAttributesQuery>(InfiniteAttributesDocument, variables);
+    },
+    all(variables: InfiniteAttributesQueryVariables) {
+      const sdk: InfiniteListSdk<InfiniteAttributesQuery, InfiniteAttributesQueryVariables> = {
+        listInfinite: (v) => client.request<InfiniteAttributesQuery>(InfiniteAttributesDocument, v),
+      };
+      return fetchAllInfinite(sdk, variables, (res) => res.infiniteAttributes);
+    },
+  };
+
+  return { ...paginated, ...infinite };
+}

package/src/services/brands.ts

@@ -0,0 +1,41 @@
+import { GraphQLClient } from "graphql-request";
+import {
+  PaginatedBrandsDocument,
+  PaginatedBrandsQuery,
+  PaginatedBrandsQueryVariables,
+  InfiniteBrandsDocument,
+  InfiniteBrandsQuery,
+  InfiniteBrandsQueryVariables,
+} from "@dokamerce/graphql";
+import { fetchAllInfinite, InfiniteListSdk } from "@/utils/fetch-all-infinite.util";
+
+export interface BrandsSdk { 
+  // Paginated queries 
+  paginated: (variables?: PaginatedBrandsQueryVariables) => Promise<PaginatedBrandsQuery>; 
+  // Infinite queries 
+  infinite: (variables: InfiniteBrandsQueryVariables) => Promise<InfiniteBrandsQuery>; 
+  all: (variables: InfiniteBrandsQueryVariables) => Promise<InfiniteBrandsQuery["infiniteBrands"]["edges"][number]["node"][]>; 
+}
+
+export function createBrandsSdk(client: GraphQLClient): BrandsSdk {
+ 
+  const paginated = {
+    paginated(variables: PaginatedBrandsQueryVariables = {}) {
+      return client.request<PaginatedBrandsQuery>(PaginatedBrandsDocument, variables);
+    },
+  };
+
+  const infinite = {
+    infinite(variables: InfiniteBrandsQueryVariables) {
+      return client.request<InfiniteBrandsQuery>(InfiniteBrandsDocument, variables);
+    },
+    all(variables: InfiniteBrandsQueryVariables) {
+      const sdk: InfiniteListSdk<InfiniteBrandsQuery, InfiniteBrandsQueryVariables> = {
+        listInfinite: (v) => client.request<InfiniteBrandsQuery>(InfiniteBrandsDocument, v),
+      };
+      return fetchAllInfinite(sdk, variables, (res) => res.infiniteBrands);
+    },
+  };
+
+  return { ...paginated, ...infinite };
+}

package/src/services/categories.ts

@@ -0,0 +1,41 @@
+import { GraphQLClient } from "graphql-request";
+import {
+  PaginatedCategoriesDocument,
+  PaginatedCategoriesQuery,
+  PaginatedCategoriesQueryVariables,
+  InfiniteCategoriesDocument,
+  InfiniteCategoriesQuery,
+  InfiniteCategoriesQueryVariables,
+} from "@dokamerce/graphql";
+import { fetchAllInfinite, InfiniteListSdk } from "@/utils/fetch-all-infinite.util";
+
+export interface CategoriesSdk { 
+  // Paginated queries 
+  paginated: (variables?: PaginatedCategoriesQueryVariables) => Promise<PaginatedCategoriesQuery>; 
+  // Infinite queries 
+  infinite: (variables: InfiniteCategoriesQueryVariables) => Promise<InfiniteCategoriesQuery>; 
+  all: (variables: InfiniteCategoriesQueryVariables) => Promise<InfiniteCategoriesQuery["infiniteCategories"]["edges"][number]["node"][]>; 
+}
+
+export function createCategoriesSdk(client: GraphQLClient): CategoriesSdk {
+ 
+  const paginated = {
+    paginated(variables: PaginatedCategoriesQueryVariables = {}) {
+      return client.request<PaginatedCategoriesQuery>(PaginatedCategoriesDocument, variables);
+    },
+  };
+
+  const infinite = {
+    infinite(variables: InfiniteCategoriesQueryVariables) {
+      return client.request<InfiniteCategoriesQuery>(InfiniteCategoriesDocument, variables);
+    },
+    all(variables: InfiniteCategoriesQueryVariables) {
+      const sdk: InfiniteListSdk<InfiniteCategoriesQuery, InfiniteCategoriesQueryVariables> = {
+        listInfinite: (v) => client.request<InfiniteCategoriesQuery>(InfiniteCategoriesDocument, v),
+      };
+      return fetchAllInfinite(sdk, variables, (res) => res.infiniteCategories);
+    },
+  };
+
+  return { ...paginated, ...infinite };
+}

package/src/services/colors.ts

@@ -0,0 +1,41 @@
+import { GraphQLClient } from "graphql-request";
+import {
+  PaginatedColorsDocument,
+  PaginatedColorsQuery,
+  PaginatedColorsQueryVariables,
+  InfiniteColorsDocument,
+  InfiniteColorsQuery,
+  InfiniteColorsQueryVariables,
+} from "@dokamerce/graphql";
+import { fetchAllInfinite, InfiniteListSdk } from "@/utils/fetch-all-infinite.util";
+
+export interface ColorsSdk { 
+  // Paginated queries 
+  paginated: (variables?: PaginatedColorsQueryVariables) => Promise<PaginatedColorsQuery>; 
+  // Infinite queries 
+  infinite: (variables: InfiniteColorsQueryVariables) => Promise<InfiniteColorsQuery>; 
+  all: (variables: InfiniteColorsQueryVariables) => Promise<InfiniteColorsQuery["infiniteColors"]["edges"][number]["node"][]>; 
+}
+
+export function createColorsSdk(client: GraphQLClient): ColorsSdk {
+ 
+  const paginated = {
+    paginated(variables: PaginatedColorsQueryVariables = {}) {
+      return client.request<PaginatedColorsQuery>(PaginatedColorsDocument, variables);
+    },
+  };
+
+  const infinite = {
+    infinite(variables: InfiniteColorsQueryVariables) {
+      return client.request<InfiniteColorsQuery>(InfiniteColorsDocument, variables);
+    },
+    all(variables: InfiniteColorsQueryVariables) {
+      const sdk: InfiniteListSdk<InfiniteColorsQuery, InfiniteColorsQueryVariables> = {
+        listInfinite: (v) => client.request<InfiniteColorsQuery>(InfiniteColorsDocument, v),
+      };
+      return fetchAllInfinite(sdk, variables, (res) => res.infiniteColors);
+    },
+  };
+
+  return { ...paginated, ...infinite };
+}

package/src/services/customers.ts

@@ -0,0 +1,60 @@
+import { GraphQLClient } from "graphql-request";
+import {
+  CreateCustomerDocument,
+  CreateCustomerMutation,
+  CreateCustomerMutationVariables,
+  UpdateCustomerDocument,
+  UpdateCustomerMutation,
+  UpdateCustomerMutationVariables,
+  PaginatedCustomersDocument,
+  PaginatedCustomersQuery,
+  PaginatedCustomersQueryVariables,
+  InfiniteCustomersDocument,
+  InfiniteCustomersQuery,
+  InfiniteCustomersQueryVariables,
+} from "@dokamerce/graphql";
+import { fetchAllInfinite, InfiniteListSdk } from "@/utils/fetch-all-infinite.util";
+
+
+export interface CustomersSdk { 
+  // Mutations 
+  create: (variables: CreateCustomerMutationVariables) => Promise<CreateCustomerMutation>; 
+  update: (variables: UpdateCustomerMutationVariables) => Promise<UpdateCustomerMutation>; 
+  // Paginated queries 
+  paginated: (variables?: PaginatedCustomersQueryVariables) => Promise<PaginatedCustomersQuery>; 
+  // Infinite queries 
+  infinite: (variables: InfiniteCustomersQueryVariables) => Promise<InfiniteCustomersQuery>; 
+  all: (variables: InfiniteCustomersQueryVariables) => Promise<InfiniteCustomersQuery["infiniteCustomers"]["edges"][number]["node"][]>; 
+}
+
+
+export function createCustomersSdk(client: GraphQLClient): CustomersSdk {
+  const mutations = {
+    create(variables: CreateCustomerMutationVariables) {
+      return client.request<CreateCustomerMutation>(CreateCustomerDocument, variables);
+    },
+    update(variables: UpdateCustomerMutationVariables) {
+      return client.request<UpdateCustomerMutation>(UpdateCustomerDocument, variables);
+    }
+  };
+
+  const paginated = {
+    paginated(variables: PaginatedCustomersQueryVariables = {}) {
+      return client.request<PaginatedCustomersQuery>(PaginatedCustomersDocument, variables);
+    },
+  };
+
+  const infinite = {
+    infinite(variables: InfiniteCustomersQueryVariables) {
+      return client.request<InfiniteCustomersQuery>(InfiniteCustomersDocument, variables);
+    },
+    all(variables: InfiniteCustomersQueryVariables) {
+      const sdk: InfiniteListSdk<InfiniteCustomersQuery, InfiniteCustomersQueryVariables> = {
+        listInfinite: (v) => client.request<InfiniteCustomersQuery>(InfiniteCustomersDocument, v),
+      };
+      return fetchAllInfinite(sdk, variables, (res) => res.infiniteCustomers);
+    },
+  };
+
+  return { ...mutations, ...paginated, ...infinite };
+}

package/src/services/files.ts

@@ -0,0 +1,58 @@
+import { GraphQLClient } from "graphql-request";
+import {
+  InitiateFileUploadDocument,
+  InitiateFileUploadMutation,
+  InitiateFileUploadMutationVariables,
+  CompleteFileUploadDocument,
+  CompleteFileUploadMutation,
+  CompleteFileUploadMutationVariables,
+  FileDocument,
+  FileQuery,
+  FileQueryVariables,
+} from "@dokamerce/graphql";
+
+export interface FileUploadSdk {
+  // Mutations
+  initiate: (
+    variables: InitiateFileUploadMutationVariables
+  ) => Promise<InitiateFileUploadMutation>;
+
+  complete: (
+    variables: CompleteFileUploadMutationVariables
+  ) => Promise<CompleteFileUploadMutation>;
+
+  // Queries
+  file: (
+    variables: FileQueryVariables
+  ) => Promise<FileQuery>;
+}
+
+
+export function createFileUploadSdk(client: GraphQLClient): FileUploadSdk {
+  const mutations = {
+    initiate(variables: InitiateFileUploadMutationVariables) {
+      return client.request<InitiateFileUploadMutation>(
+        InitiateFileUploadDocument,
+        variables
+      );
+    },
+
+    complete(variables: CompleteFileUploadMutationVariables) {
+      return client.request<CompleteFileUploadMutation>(
+        CompleteFileUploadDocument,
+        variables
+      );
+    },
+  };
+
+  const queries = {
+    file(variables: FileQueryVariables) {
+      return client.request<FileQuery>(FileDocument, variables);
+    },
+  };
+
+  return {
+    ...mutations,
+    ...queries,
+  };
+}

package/src/services/index.ts

@@ -0,0 +1,9 @@
+export * from './products'
+export * from './sellers'
+export * from './colors'
+export * from './files'
+export * from './categories'
+export * from './brands'
+export * from './attributes'
+export * from './customers'
+export * from './orders'

package/src/services/metrics.ts

@@ -0,0 +1,39 @@
+import { GraphQLClient } from "graphql-request";
+import {
+  // PaginatedMetricsDocument,
+  // PaginatedMetricsQuery,
+  // PaginatedMetricsQueryVariables,
+  InfiniteMetricsDocument,
+  InfiniteMetricsQuery,
+  InfiniteMetricsQueryVariables,
+} from "@dokamerce/graphql";
+import { fetchAllInfinite, InfiniteListSdk } from "@/utils/fetch-all-infinite.util";
+
+export interface MetricsSdk { 
+  // Infinite queries 
+  infinite: (variables: InfiniteMetricsQueryVariables) => Promise<InfiniteMetricsQuery>; 
+  all: (variables: InfiniteMetricsQueryVariables) => Promise<InfiniteMetricsQuery["infiniteMetrics"]["edges"][number]["node"][]>; 
+}
+
+export function createMetricsSdk(client: GraphQLClient): MetricsSdk {
+ 
+  // const paginated = {
+  //   list(variables: PaginatedMetricsQueryVariables = {}) {
+  //     return client.request<PaginatedMetricsQuery>(PaginatedMetricsDocument, variables);
+  //   },
+  // };
+
+  const infinite = {
+    infinite(variables: InfiniteMetricsQueryVariables) {
+      return client.request<InfiniteMetricsQuery>(InfiniteMetricsDocument, variables);
+    },
+    all(variables: InfiniteMetricsQueryVariables) {
+      const sdk: InfiniteListSdk<InfiniteMetricsQuery, InfiniteMetricsQueryVariables> = {
+        listInfinite: (v) => client.request<InfiniteMetricsQuery>(InfiniteMetricsDocument, v),
+      };
+      return fetchAllInfinite(sdk, variables, (res) => res.infiniteMetrics);
+    },
+  };
+
+  return { ...infinite };
+}

package/src/services/orders.ts

@@ -0,0 +1,59 @@
+import { GraphQLClient } from "graphql-request";
+import {
+  CreateOrderDocument,
+  CreateOrderMutation,
+  CreateOrderMutationVariables,
+  UpdateOrderDocument,
+  UpdateOrderMutation,
+  UpdateOrderMutationVariables,
+  PaginatedOrdersDocument,
+  PaginatedOrdersQuery,
+  PaginatedOrdersQueryVariables,
+  InfiniteOrdersDocument,
+  InfiniteOrdersQuery,
+  InfiniteOrdersQueryVariables,
+} from "@dokamerce/graphql";
+import { fetchAllInfinite, InfiniteListSdk } from "@/utils/fetch-all-infinite.util";
+
+export interface OrdersSdk { 
+  // Mutations 
+  create: (variables: CreateOrderMutationVariables) => Promise<CreateOrderMutation>; 
+  update: (variables: UpdateOrderMutationVariables) => Promise<UpdateOrderMutation>; 
+  // Paginated queries 
+  paginated: (variables?: PaginatedOrdersQueryVariables) => Promise<PaginatedOrdersQuery>; 
+  // Infinite queries 
+  infinite: (variables: InfiniteOrdersQueryVariables) => Promise<InfiniteOrdersQuery>; 
+  all: (variables: InfiniteOrdersQueryVariables) => Promise<InfiniteOrdersQuery["infiniteOrders"]["edges"][number]["node"][]>; 
+}
+
+
+export function createOrdersSdk(client: GraphQLClient): OrdersSdk {
+  const mutations = {
+    create(variables: CreateOrderMutationVariables) {
+      return client.request<CreateOrderMutation>(CreateOrderDocument, variables);
+    },
+    update(variables: UpdateOrderMutationVariables) {
+      return client.request<UpdateOrderMutation>(UpdateOrderDocument, variables);
+    }
+  };
+
+  const paginated = {
+    paginated(variables: PaginatedOrdersQueryVariables = {}) {
+      return client.request<PaginatedOrdersQuery>(PaginatedOrdersDocument, variables);
+    },
+  };
+
+  const infinite = {
+    infinite(variables: InfiniteOrdersQueryVariables) {
+      return client.request<InfiniteOrdersQuery>(InfiniteOrdersDocument, variables);
+    },
+    all(variables: InfiniteOrdersQueryVariables) {
+      const sdk: InfiniteListSdk<InfiniteOrdersQuery, InfiniteOrdersQueryVariables> = {
+        listInfinite: (v) => client.request<InfiniteOrdersQuery>(InfiniteOrdersDocument, v),
+      };
+      return fetchAllInfinite(sdk, variables, (res) => res.infiniteOrders);
+    },
+  };
+
+  return { ...mutations, ...paginated, ...infinite };
+}

package/src/services/products.ts

@@ -0,0 +1,65 @@
+import { GraphQLClient } from "graphql-request";
+import {
+  CreateProductDocument,
+  CreateProductMutation,
+  CreateProductMutationVariables,
+  UpdateProductDocument,
+  UpdateProductMutation,
+  UpdateProductMutationVariables,
+  DeleteProductDocument,
+  DeleteProductMutation,
+  DeleteProductMutationVariables,
+  PaginatedProductsDocument,
+  PaginatedProductsQuery,
+  PaginatedProductsQueryVariables,
+  InfiniteProductsDocument,
+  InfiniteProductsQuery,
+  InfiniteProductsQueryVariables,
+} from "@dokamerce/graphql";
+import { fetchAllInfinite, InfiniteListSdk } from "@/utils/fetch-all-infinite.util";
+
+
+export interface ProductsSdk { 
+  // Mutations 
+  create: (variables: CreateProductMutationVariables) => Promise<CreateProductMutation>; update: (variables: UpdateProductMutationVariables) => Promise<UpdateProductMutation>; 
+  delete: (variables: DeleteProductMutationVariables) => Promise<DeleteProductMutation>; 
+  // Paginated queries 
+  paginated: (variables?: PaginatedProductsQueryVariables) => Promise<PaginatedProductsQuery>; 
+  // Infinite queries 
+  infinite: (variables: InfiniteProductsQueryVariables) => Promise<InfiniteProductsQuery>; 
+  all: (variables: InfiniteProductsQueryVariables) => Promise<InfiniteProductsQuery["infiniteProducts"]["edges"][number]["node"][]>; 
+}
+
+export function createProductsSdk(client: GraphQLClient) : ProductsSdk {
+  const mutations = {
+    create(variables: CreateProductMutationVariables) {
+      return client.request<CreateProductMutation>(CreateProductDocument, variables);
+    },
+    update(variables: UpdateProductMutationVariables) {
+      return client.request<UpdateProductMutation>(UpdateProductDocument, variables);
+    },
+    delete(variables: DeleteProductMutationVariables) {
+      return client.request<DeleteProductMutation>(DeleteProductDocument, variables);
+    },
+  };
+
+  const paginated = {
+    paginated(variables: PaginatedProductsQueryVariables = {}) {
+      return client.request<PaginatedProductsQuery>(PaginatedProductsDocument, variables);
+    },
+  };
+
+  const infinite = {
+    infinite(variables: InfiniteProductsQueryVariables) {
+      return client.request<InfiniteProductsQuery>(InfiniteProductsDocument, variables);
+    },
+    all(variables: InfiniteProductsQueryVariables) {
+      const sdk: InfiniteListSdk<InfiniteProductsQuery, InfiniteProductsQueryVariables> = {
+        listInfinite: (v) => client.request<InfiniteProductsQuery>(InfiniteProductsDocument, v),
+      };
+      return fetchAllInfinite(sdk, variables, (res) => res.infiniteProducts);
+    },
+  };
+
+  return { ...mutations, ...paginated, ...infinite };
+}