@dokamerce/web-sdk 0.9.0 → 0.9.1

package/README.md

@@ -1,47 +1,89 @@
+# @dokamerce/web-sdk
+
+A lightweight, TypeScript‑ready SDK for interacting with Dokamerce GraphQL APIs.  
+It provides a simple, intuitive interface for creating, updating, listing, and deleting products, with built‑in support for pagination and infinite fetching.
+
+---
+
+## 🚀 Installation
+
+```bash
+npm install @dokamerce/web-sdk graphql graphql-request
+# or
+yarn add @dokamerce/web-sdk graphql graphql-request
+
+📦 Features
+🔗 Easy GraphQL client integration
+
+🛍️ Product CRUD operations (create, update, delete)
+
+📑 Pagination and infinite fetch helpers
+
+✅ TypeScript definitions included
+
+⚡ Lightweight and modular
+🛠 Usage Example
+ts
 import { GraphQLClient } from "graphql-request";
-import { createProductsSdk } from "@/sdk/products-sdk";
+import { createProductsSdk } from "@dokamerce/web-sdk";
 
 async function main() {
-  // 1️⃣ Initialize GraphQL client
   const client = new GraphQLClient("https://api.example.com/graphql", {
-    headers: {
-      Authorization: `Bearer YOUR_API_TOKEN`,
-    },
+    headers: { Authorization: `Bearer YOUR_API_TOKEN` },
   });
 
-  // 2️⃣ Create the Products SDK
   const productsSdk = createProductsSdk(client);
 
-  // 3️⃣ Create a new product
   const newProduct = await productsSdk.create({
-    input: {
-      name: "Sample Product",
-      price: 19.99,
-      description: "This is a sample product",
-    },
+    input: { name: "Sample Product", price: 19.99, description: "This is a sample product" },
   });
   console.log("Created Product:", newProduct.createProduct);
 
-  // 4️⃣ Update the product
   const updatedProduct = await productsSdk.update({
     id: newProduct.createProduct.id,
-    input: {
-      price: 24.99,
-    },
+    input: { price: 24.99 },
   });
   console.log("Updated Product Price:", updatedProduct.updateProduct.price);
 
-  // 5️⃣ Fetch products (paginated)
   const paginated = await productsSdk.list({ page: 1, limit: 10 });
   console.log("Paginated Products:", paginated.paginatedProducts.items);
 
-  // 6️⃣ Fetch products (infinite)
   const allProducts = await productsSdk.fetchAll({ cursor: null, limit: 5 });
   console.log("All Products via Infinite Fetch:", allProducts);
 
-  // 7️⃣ Delete the product
   await productsSdk.delete({ id: newProduct.createProduct.id });
   console.log("Product deleted!");
 }
 
 main().catch(console.error);
+📖 API Reference
+createProductsSdk(client: GraphQLClient)
+Initializes the SDK with a GraphQL client.
+
+Methods
+create({ input }) → Creates a new product.
+
+update({ id, input }) → Updates an existing product.
+
+list({ page, limit }) → Fetches products with pagination.
+
+fetchAll({ cursor, limit }) → Fetches products using infinite scrolling.
+
+delete({ id }) → Deletes a product by ID.
+
+🧩 Requirements
+Node.js  ≥ 16
+
+GraphQL API endpoint
+
+Valid API token
+
+📜 License
+MIT © Dokamerce
+🤝 Contributing
+Contributions, issues, and feature requests are welcome!
+Feel free to open a PR or start a discussion in the GitHub repository.
+
+Code
+
+I’ll now prepare this as a **downloadable `README.md` file card** so you can grab it direc

package/package.json

@@ -1,9 +1,19 @@
 {
   "name": "@dokamerce/web-sdk",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "rimraf dist && tsc",
     "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
@@ -13,7 +23,9 @@
   },
   "dependencies": {
     "graphql": "^16.12.0",
-    "graphql-request": "^7.2.0",
+    "graphql-request": "^7.2.0"
+  },
+  "devDependencies": {
     "rimraf": "^6.1.2",
     "typescript": "^5.9.2"
   }

package/.ls-lint.yml

@@ -1,8 +0,0 @@
-ls:
-  src:
-    .ts: regex:[a-z0-9-]+(\.[a-z]+)?(\.spec)? | regex:[a-z0-9-]+(\.[a-z]+)?(\.mock)?
-    .d.ts: regex:[a-z0-9-]+(\.[a-z]+)?(\.spec)? | regex:[a-z0-9-]+(\.[a-z]+)?(\.mock)?
-
-ignore:
-  - .git
-  - node_modules

package/.nvmrc

@@ -1 +0,0 @@
-v22.13.1

package/.prettierrc.js

@@ -1,3 +0,0 @@
-module.exports = {
-  "trailingComma": "all"
-}

package/codegen.yml

@@ -1,11 +0,0 @@
-schema: "https://api.example.com/graphql"
-documents: "src/queries/**/*.graphql"
-generates:
-  src/types/graphql.ts:
-    plugins:
-      - "typescript"
-      - "typescript-operations"
-      - "typescript-graphql-request"
-    config:
-      rawRequest: false
-      useTypeImports: true

package/src/constants/graphql-base.constant.ts

@@ -1 +0,0 @@
-export const GRAPHQL_BASE_URL = ""

package/src/contexts/index.ts

@@ -1,33 +0,0 @@
-import { GraphQLClient } from "graphql-request";
-
-type SDKStatus = "unknown" | "ready" | "initializing" | "change" | "fails"
-
-interface ContextInterface {
-  status: SDKStatus;
-  client: GraphQLClient | undefined | null;
-}
-
-export const _context: ContextInterface = {
-  status: "unknown",
-  client: null,
-};
-
-export function setSdkClient(client: GraphQLClient) {
-  if (!_context.client) {
-    _context.client = client;
-  }
-  return _context.client;
-}
-
-export function getSdkClient(): GraphQLClient {
-  if (!_context.client) throw new Error("ou must initialize first");
-  return _context.client;
-}
-
-export function setSdkStatus(status: SDKStatus) {
-  _context.status = status;
-}
-
-export function getSdkStatus(): SDKStatus {
-  return _context.status;
-}

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

@@ -1,19 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,74 +0,0 @@
-/**
- * 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

@@ -1,42 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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 };
-}

package/src/services/sellers.ts

@@ -1,91 +0,0 @@
-import { GraphQLClient } from "graphql-request";
-import {
-  CreateSellerDocument,
-  CreateSellerMutation,
-  CreateSellerMutationVariables,
-  UpdateSellerDocument,
-  UpdateSellerMutation,
-  UpdateSellerMutationVariables,
-  PaginatedSellersDocument,
-  PaginatedSellersQuery,
-  PaginatedSellersQueryVariables,
-  InfiniteSellersDocument,
-  InfiniteSellersQuery,
-  InfiniteSellersQueryVariables,
-} from "@dokamerce/graphql";
-import {
-  fetchAllInfinite,
-  InfiniteListSdk,
-} from "@/utils/fetch-all-infinite.util";
-
-export interface SellersSdk {
-  // Mutations
-  create: (
-    variables: CreateSellerMutationVariables,
-  ) => Promise<CreateSellerMutation>;
-  update: (
-    variables: UpdateSellerMutationVariables,
-  ) => Promise<UpdateSellerMutation>;
-  // Paginated queries
-  paginated: (
-    variables?: PaginatedSellersQueryVariables,
-  ) => Promise<PaginatedSellersQuery>;
-  // Infinite queries
-  infinite: (
-    variables: InfiniteSellersQueryVariables,
-  ) => Promise<InfiniteSellersQuery>;
-  all: (
-    variables: InfiniteSellersQueryVariables,
-  ) => Promise<InfiniteSellersQuery["infiniteSellers"]["edges"][number]["node"][]>;
-}
-
-export function createSellersSdk(client: GraphQLClient): SellersSdk {
-  const mutations = {
-    create(variables: CreateSellerMutationVariables) {
-      return client.request<CreateSellerMutation>(
-        CreateSellerDocument,
-        variables,
-      );
-    },
-    update(variables: UpdateSellerMutationVariables) {
-      return client.request<UpdateSellerMutation>(
-        UpdateSellerDocument,
-        variables,
-      );
-    },
-  };
-
-  const paginated = {
-    paginated(variables: PaginatedSellersQueryVariables = {}) {
-      return client.request<PaginatedSellersQuery>(
-        PaginatedSellersDocument,
-        variables,
-      );
-    },
-  };
-
-  const infinite = {
-    infinite(variables: InfiniteSellersQueryVariables) {
-      return client.request<InfiniteSellersQuery>(
-        InfiniteSellersDocument,
-        variables,
-      );
-    },
-    all(variables: InfiniteSellersQueryVariables) {
-      const sdk: InfiniteListSdk<
-        InfiniteSellersQuery,
-        InfiniteSellersQueryVariables
-      > = {
-        listInfinite: (v) =>
-          client.request<InfiniteSellersQuery>(InfiniteSellersDocument, v),
-      };
-      return fetchAllInfinite<
-        InfiniteSellersQuery["infiniteSellers"]["edges"][number]["node"],
-        InfiniteSellersQuery,
-        InfiniteSellersQueryVariables
-      >(sdk, variables, (res) => res.infiniteSellers);
-    },
-  };
-
-  return { ...mutations, ...paginated, ...infinite };
-}

package/src/typings/pagination.typing.ts

@@ -1,18 +0,0 @@
-export type PageInfo = {
-  hasNextPage: boolean;
-  endCursor?: string | null;
-};
-
-export type Edge<T> = {
-  node: T;
-  cursor?: string;
-};
-
-export type Connection<T> = {
-  edges?: Edge<T>[] | null;
-  pageInfo?: PageInfo | null;
-};
-
-export type CursorVariables = {
-  after?: string | null;
-};

package/src/typings/sdk.typing.ts

@@ -1,27 +0,0 @@
-// import { SDKError } from "./functions/safe-call.function";
-
-import {
-  AttributesSdk,
-  BrandsSdk,
-  CategoriesSdk,
-  ColorsSdk,
-  CustomersSdk,
-  FileUploadSdk,
-  OrdersSdk,
-  ProductsSdk,
-  SellersSdk,
-} from "@/services";
-import { MetricsSdk } from "@/services/metrics";
-
-export interface DokamerceSDK {
-  products: ProductsSdk;
-  attributes: AttributesSdk;
-  brands: BrandsSdk;
-  categories: CategoriesSdk;
-  colors: ColorsSdk;
-  customers: CustomersSdk;
-  metrics: MetricsSdk;
-  files: FileUploadSdk;
-  orders: OrdersSdk;
-  sellers: SellersSdk;
-}

package/src/utils/fetch-all-infinite.util.ts

@@ -1,41 +0,0 @@
-import { Connection, CursorVariables } from "../typings/pagination.typing";
-
-export interface InfiniteListSdk<TResponse, TVariables> {
-  listInfinite(variables: TVariables): Promise<TResponse>;
-}
-
-/**
- * Generic helper to fetch all nodes from a cursor-based infinite connection
- */
-export async function fetchAllInfinite<
-  TNode,
-  TResponse,
-  TVariables extends (CursorVariables)
->(
-  sdk: InfiniteListSdk<TResponse, TVariables>,
-  variables: TVariables,
-  selectConnection: (response: TResponse) => Connection<TNode> | null | undefined
-): Promise<TNode[]> {
-  let after = variables.after;
-  const items: TNode[] = [];
-
-  while (true) {
-    const res = await sdk.listInfinite({
-      ...variables,
-      after,
-    });
-
-    const connection = selectConnection(res);
-    if (!connection) break;
-
-    const edges = connection.edges ?? [];
-    items.push(...edges.map((e) => e.node));
-
-    const pageInfo = connection.pageInfo;
-    if (!pageInfo?.hasNextPage) break;
-
-    after = pageInfo.endCursor;
-  }
-
-  return items;
-}

package/tsconfig.dev.json

@@ -1,32 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "declaration": true,
-    "removeComments": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "allowSyntheticDefaultImports": true,
-    "target": "ES2023",
-    "sourceMap": true,
-    "outDir": "./dist",
-    "incremental": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "strictFunctionTypes": true,
-    "strictNullChecks": true,
-    "strictBindCallApply": true,
-    "strictPropertyInitialization": true,
-    "noImplicitThis": true,
-    "noImplicitAny": true,
-    "alwaysStrict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "forceConsistentCasingInFileNames": false,
-    "resolveJsonModule": true,
-    "types": ["expect-more-jest", "jest", "node"],
-    "baseUrl": "./"
-  }
-}

package/tsconfig.json

@@ -1,37 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "commonjs",
-    "declaration": true,
-    "removeComments": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "allowSyntheticDefaultImports": true,
-    "target": "ES2023",
-    "sourceMap": true,
-    "outDir": "./dist",
-    "incremental": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "strictFunctionTypes": true,
-    "strictNullChecks": true,
-    "strictBindCallApply": true,
-    "strictPropertyInitialization": true,
-    "noImplicitThis": true,
-    "noImplicitAny": true,
-    "alwaysStrict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "forceConsistentCasingInFileNames": false,
-    "resolveJsonModule": true,
-    "types": ["expect-more-jest", "jest", "node"],
-    "baseUrl": "./",
-    "paths": {
-      "@dokamerce/common": ["../common/src"],
-      "@/*": ["./src/*"],
-      "@dokamerce/graphql": ["../graphql/src/gateway"],
-    }
-  },
-  "exclude": ["../../packages/graphql/__generated__/**/*.ts"]
-}