@teamnovu/kit-shopware-composables 0.0.1 → 0.0.3

package/dist/keys.d.ts

@@ -0,0 +1,27 @@
+import { MaybeRef } from 'vue';
+export declare const contextKeys: {
+    all: () => readonly ["context"];
+};
+export declare const categoryKeys: {
+    all: () => readonly ["category"];
+    lists: () => readonly ["category", "list"];
+    list: (body: MaybeRef<unknown>) => readonly ["category", "list", {
+        readonly body: unknown;
+    }];
+};
+export declare const productKeys: {
+    all: () => readonly ["product"];
+    lists: () => readonly ["product", "list"];
+    list: (url: MaybeRef<string>, body: MaybeRef<unknown>) => readonly ["product", "list", {
+        readonly url: MaybeRef<string>;
+        readonly body: unknown;
+    }];
+    details: () => readonly ["product", "detail"];
+    detail: (url: MaybeRef<string>, body: MaybeRef<unknown>) => readonly ["product", "detail", {
+        readonly url: MaybeRef<string>;
+        readonly body: unknown;
+    }];
+};
+export declare const cartKeys: {
+    get: () => readonly ["cart"];
+};

package/dist/products/useCategoryQueryOptions.d.ts

@@ -0,0 +1,17 @@
+import { operations } from '../../api-types/storeApiTypes.d.ts';
+import { MaybeRef } from 'vue';
+import { OperationBody } from '../types/query';
+import { UndefinedInitialQueryOptions } from '@tanstack/vue-query';
+import { OperationProp } from '@teamnovu/kit-shopware-api-client';
+declare const readCategoryListOperation = "readCategoryList post /category";
+export declare function useCategoryQueryOptions<Operations extends operations>(body?: MaybeRef<OperationBody<Operations, typeof readCategoryListOperation>>): UndefinedInitialQueryOptions<OperationProp<operations & Operations, "readCategoryList post /category", "response">, Error, OperationProp<operations & Operations, "readCategoryList post /category", "response">, readonly ["category", "list", {
+    readonly body: unknown;
+}]> & {
+    queryKey: readonly ["category", "list", {
+        readonly body: unknown;
+    }] & {
+        [dataTagSymbol]: OperationProp<operations & Operations, "readCategoryList post /category", "response">;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export {};

package/dist/products/useProductListingQueryOptions.d.ts

@@ -0,0 +1,19 @@
+import { operations } from '../../api-types/storeApiTypes.d.ts';
+import { MaybeRef } from 'vue';
+import { OperationBody } from '../types/query';
+import { UndefinedInitialQueryOptions } from '@tanstack/vue-query';
+import { OperationProp } from '@teamnovu/kit-shopware-api-client';
+declare const readListingOperation = "readCompactProductListing post /novu/headless/product-listing/{seoUrl}";
+export declare function useProductListingQueryOptions<Operations extends operations>(seoUrl: MaybeRef<string>, body?: MaybeRef<OperationBody<Operations, typeof readListingOperation>>): UndefinedInitialQueryOptions<OperationProp<operations & Operations, "readCompactProductListing post /novu/headless/product-listing/{seoUrl}", "response">, Error, OperationProp<operations & Operations, "readCompactProductListing post /novu/headless/product-listing/{seoUrl}", "response">, readonly ["product", "list", {
+    readonly url: MaybeRef<string>;
+    readonly body: unknown;
+}]> & {
+    queryKey: readonly ["product", "list", {
+        readonly url: MaybeRef<string>;
+        readonly body: unknown;
+    }] & {
+        [dataTagSymbol]: OperationProp<operations & Operations, "readCompactProductListing post /novu/headless/product-listing/{seoUrl}", "response">;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export {};

package/dist/products/useProductListingQueryOptions.test.d.ts

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

package/dist/products/useProductPrice.d.ts

@@ -0,0 +1,49 @@
+import { Schemas } from '../../api-types/storeApiTypes.d.ts';
+import { TierPrice } from '@shopware/helpers';
+import { ComputedRef, Ref } from 'vue';
+export type UseProductPriceReturn = {
+    /**
+     * Whole calculated price object
+     */
+    price: ComputedRef<Schemas['CalculatedPrice'] | undefined>;
+    /**
+     * Calculated price value for one selling unit
+     */
+    totalPrice: ComputedRef<number | undefined>;
+    /**
+     * Current unit price value
+     */
+    unitPrice: ComputedRef<number | undefined>;
+    /**
+     * Can be used if isListPrice is set to true
+     */
+    referencePrice: ComputedRef<Schemas['CalculatedPrice']['referencePrice'] | undefined>;
+    /**
+     * determines if `price` contains the minimum tier price
+     */
+    displayFrom: ComputedRef<boolean>;
+    /**
+     * cheapest price value for a variant if exists
+     */
+    displayFromVariants: ComputedRef<number | false | undefined>;
+    /**
+     * array of TierPrice object
+     */
+    tierPrices: ComputedRef<TierPrice[]>;
+    /**
+     * determines whether a discount price is set
+     */
+    isListPrice: ComputedRef<boolean>;
+    /**
+     * price for products with regulation price
+     */
+    regulationPrice: ComputedRef<number | undefined>;
+};
+/**
+ * The purpose of the `useProductPrice` function is to abstract the logic
+ * to expose most useful helpers for price displaying.
+ *
+ * @public
+ * @category Product
+ */
+export declare function useProductPrice(product: Ref<Schemas['Product'] | undefined>): UseProductPriceReturn;

package/dist/products/useProductQueryOptions.d.ts

@@ -0,0 +1,19 @@
+import { operations } from '../../api-types/storeApiTypes.d.ts';
+import { MaybeRef } from 'vue';
+import { OperationBody } from '../types/query';
+import { UndefinedInitialQueryOptions } from '@tanstack/vue-query';
+import { OperationProp } from '@teamnovu/kit-shopware-api-client';
+declare const readCustomProductDetailOperation = "readCustomProductDetail post /novu/headless/product/{seoUrl}";
+export declare function useProductQueryOptions<Operations extends operations>(seoUrl: MaybeRef<string>, body?: MaybeRef<OperationBody<Operations, typeof readCustomProductDetailOperation>>): UndefinedInitialQueryOptions<OperationProp<operations & Operations, "readCustomProductDetail post /novu/headless/product/{seoUrl}", "response">, Error, OperationProp<operations & Operations, "readCustomProductDetail post /novu/headless/product/{seoUrl}", "response">, readonly ["product", "detail", {
+    readonly url: MaybeRef<string>;
+    readonly body: unknown;
+}]> & {
+    queryKey: readonly ["product", "detail", {
+        readonly url: MaybeRef<string>;
+        readonly body: unknown;
+    }] & {
+        [dataTagSymbol]: OperationProp<operations & Operations, "readCustomProductDetail post /novu/headless/product/{seoUrl}", "response">;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export {};

package/dist/products/useProductVariantForOptions.d.ts

@@ -0,0 +1,276 @@
+import { Schemas, components, GenericRecord } from '../../api-types/storeApiTypes.d.ts';
+import { MaybeRef, ComputedRef } from 'vue';
+type DetailProduct<S extends Schemas> = S['CustomProductDetailResponse']['product'];
+export declare function getProductVariantForOptions<S extends Schemas>(product: DetailProduct<S>, optionIds: string[]): {
+    active?: boolean;
+    apiAlias: "product";
+    readonly available?: boolean;
+    readonly availableStock?: number;
+    calculatedCheapestPrice?: {
+        apiAlias?: "calculated_cheapest_price";
+        hasRange?: boolean;
+        listPrice?: components["schemas"]["ListPrice"] | null;
+        quantity?: number;
+        referencePrice?: components["schemas"]["ReferencePrice"] | null;
+        regulationPrice?: {
+            price: number;
+        } | null;
+        totalPrice?: number;
+        unitPrice?: number;
+        variantId?: string | null;
+    };
+    calculatedMaxPurchase?: number;
+    calculatedPrice: components["schemas"]["CalculatedPrice"];
+    calculatedPrices: components["schemas"]["CalculatedPrice"][];
+    canonicalProduct?: components["schemas"]["Product"];
+    canonicalProductId?: string;
+    canonicalProductVersionId?: string;
+    categories?: components["schemas"]["Category"][];
+    categoriesRo?: components["schemas"]["Category"][];
+    readonly categoryIds?: string[];
+    readonly categoryTree?: string[];
+    readonly childCount?: number;
+    children?: components["schemas"]["Product"][];
+    cmsPage?: components["schemas"]["CmsPage"];
+    cmsPageId?: string;
+    cmsPageVersionId?: string;
+    configuratorSettings?: components["schemas"]["ProductConfiguratorSetting"][];
+    cover?: components["schemas"]["ProductMedia"];
+    coverId?: string;
+    readonly createdAt?: string;
+    crossSellings?: components["schemas"]["ProductCrossSelling"][];
+    customFields?: GenericRecord;
+    deliveryTime?: components["schemas"]["DeliveryTime"];
+    deliveryTimeId?: string;
+    description?: string;
+    readonly displayGroup?: string;
+    downloads?: components["schemas"]["ProductDownload"][];
+    ean?: string;
+    extensions?: {
+        novuSeoUrls?: GenericRecord;
+        variants?: GenericRecord;
+    };
+    height?: number;
+    id: string;
+    isCloseout?: boolean;
+    isNew?: boolean;
+    keywords?: string;
+    length?: number;
+    mainCategories?: components["schemas"]["MainCategory"][];
+    manufacturer?: components["schemas"]["ProductManufacturer"];
+    manufacturerId?: string;
+    manufacturerNumber?: string;
+    markAsTopseller?: boolean;
+    maxPurchase?: number;
+    media?: components["schemas"]["ProductMedia"][];
+    metaDescription?: string;
+    metaTitle?: string;
+    minPurchase?: number;
+    name: string;
+    readonly optionIds?: string[];
+    options?: components["schemas"]["PropertyGroupOption"][];
+    packUnit?: string;
+    packUnitPlural?: string;
+    parent?: components["schemas"]["Product"];
+    parentId?: string;
+    parentVersionId?: string;
+    productManufacturerVersionId?: string;
+    productMediaVersionId?: string;
+    productNumber: string;
+    productReviews?: components["schemas"]["ProductReview"][];
+    properties?: components["schemas"]["PropertyGroupOption"][];
+    readonly propertyIds?: string[];
+    purchaseSteps?: number;
+    purchaseUnit?: number;
+    readonly ratingAverage?: number;
+    referenceUnit?: number;
+    releaseDate?: string;
+    restockTime?: number;
+    readonly sales?: number;
+    seoCategory: components["schemas"]["Category"];
+    seoUrls?: components["schemas"]["SeoUrl"][];
+    shippingFree?: boolean;
+    sortedProperties?: GenericRecord;
+    readonly states?: string[];
+    stock: number;
+    readonly streamIds?: string[];
+    streams?: components["schemas"]["ProductStream"][];
+    readonly tagIds?: string[];
+    tags?: components["schemas"]["Tag"][];
+    tax?: components["schemas"]["Tax"];
+    taxId: string;
+    translated: {
+        canonicalProductId: string;
+        canonicalProductVersionId: string;
+        cmsPageId: string;
+        cmsPageVersionId: string;
+        coverId: string;
+        deliveryTimeId: string;
+        description: string;
+        displayGroup: string;
+        ean: string;
+        keywords: string;
+        manufacturerId: string;
+        manufacturerNumber: string;
+        metaDescription: string;
+        metaTitle: string;
+        name: string;
+        packUnit: string;
+        packUnitPlural: string;
+        parentId: string;
+        parentVersionId: string;
+        productManufacturerVersionId: string;
+        productMediaVersionId: string;
+        productNumber: string;
+        releaseDate: string;
+        taxId: string;
+        unitId: string;
+        versionId: string;
+    };
+    unit?: components["schemas"]["Unit"];
+    unitId?: string;
+    readonly updatedAt?: string;
+    variantListingConfig?: {
+        displayParent?: boolean;
+    } | null;
+    versionId?: string;
+    weight?: number;
+    width?: number;
+} | undefined;
+export declare function useProductVariantForOptions<S extends Schemas>(product: MaybeRef<DetailProduct<S>>, optionIds: MaybeRef<string[]>): ComputedRef<{
+    active?: boolean;
+    apiAlias: "product";
+    readonly available?: boolean;
+    readonly availableStock?: number;
+    calculatedCheapestPrice?: {
+        apiAlias?: "calculated_cheapest_price";
+        hasRange?: boolean;
+        listPrice?: components["schemas"]["ListPrice"] | null;
+        quantity?: number;
+        referencePrice?: components["schemas"]["ReferencePrice"] | null;
+        regulationPrice?: {
+            price: number;
+        } | null;
+        totalPrice?: number;
+        unitPrice?: number;
+        variantId?: string | null;
+    };
+    calculatedMaxPurchase?: number;
+    calculatedPrice: components["schemas"]["CalculatedPrice"];
+    calculatedPrices: components["schemas"]["CalculatedPrice"][];
+    canonicalProduct?: components["schemas"]["Product"];
+    canonicalProductId?: string;
+    canonicalProductVersionId?: string;
+    categories?: components["schemas"]["Category"][];
+    categoriesRo?: components["schemas"]["Category"][];
+    readonly categoryIds?: string[];
+    readonly categoryTree?: string[];
+    readonly childCount?: number;
+    children?: components["schemas"]["Product"][];
+    cmsPage?: components["schemas"]["CmsPage"];
+    cmsPageId?: string;
+    cmsPageVersionId?: string;
+    configuratorSettings?: components["schemas"]["ProductConfiguratorSetting"][];
+    cover?: components["schemas"]["ProductMedia"];
+    coverId?: string;
+    readonly createdAt?: string;
+    crossSellings?: components["schemas"]["ProductCrossSelling"][];
+    customFields?: GenericRecord;
+    deliveryTime?: components["schemas"]["DeliveryTime"];
+    deliveryTimeId?: string;
+    description?: string;
+    readonly displayGroup?: string;
+    downloads?: components["schemas"]["ProductDownload"][];
+    ean?: string;
+    extensions?: {
+        novuSeoUrls?: GenericRecord;
+        variants?: GenericRecord;
+    };
+    height?: number;
+    id: string;
+    isCloseout?: boolean;
+    isNew?: boolean;
+    keywords?: string;
+    length?: number;
+    mainCategories?: components["schemas"]["MainCategory"][];
+    manufacturer?: components["schemas"]["ProductManufacturer"];
+    manufacturerId?: string;
+    manufacturerNumber?: string;
+    markAsTopseller?: boolean;
+    maxPurchase?: number;
+    media?: components["schemas"]["ProductMedia"][];
+    metaDescription?: string;
+    metaTitle?: string;
+    minPurchase?: number;
+    name: string;
+    readonly optionIds?: string[];
+    options?: components["schemas"]["PropertyGroupOption"][];
+    packUnit?: string;
+    packUnitPlural?: string;
+    parent?: components["schemas"]["Product"];
+    parentId?: string;
+    parentVersionId?: string;
+    productManufacturerVersionId?: string;
+    productMediaVersionId?: string;
+    productNumber: string;
+    productReviews?: components["schemas"]["ProductReview"][];
+    properties?: components["schemas"]["PropertyGroupOption"][];
+    readonly propertyIds?: string[];
+    purchaseSteps?: number;
+    purchaseUnit?: number;
+    readonly ratingAverage?: number;
+    referenceUnit?: number;
+    releaseDate?: string;
+    restockTime?: number;
+    readonly sales?: number;
+    seoCategory: components["schemas"]["Category"];
+    seoUrls?: components["schemas"]["SeoUrl"][];
+    shippingFree?: boolean;
+    sortedProperties?: GenericRecord;
+    readonly states?: string[];
+    stock: number;
+    readonly streamIds?: string[];
+    streams?: components["schemas"]["ProductStream"][];
+    readonly tagIds?: string[];
+    tags?: components["schemas"]["Tag"][];
+    tax?: components["schemas"]["Tax"];
+    taxId: string;
+    translated: {
+        canonicalProductId: string;
+        canonicalProductVersionId: string;
+        cmsPageId: string;
+        cmsPageVersionId: string;
+        coverId: string;
+        deliveryTimeId: string;
+        description: string;
+        displayGroup: string;
+        ean: string;
+        keywords: string;
+        manufacturerId: string;
+        manufacturerNumber: string;
+        metaDescription: string;
+        metaTitle: string;
+        name: string;
+        packUnit: string;
+        packUnitPlural: string;
+        parentId: string;
+        parentVersionId: string;
+        productManufacturerVersionId: string;
+        productMediaVersionId: string;
+        productNumber: string;
+        releaseDate: string;
+        taxId: string;
+        unitId: string;
+        versionId: string;
+    };
+    unit?: components["schemas"]["Unit"];
+    unitId?: string;
+    readonly updatedAt?: string;
+    variantListingConfig?: {
+        displayParent?: boolean;
+    } | null;
+    versionId?: string;
+    weight?: number;
+    width?: number;
+} | undefined>;
+export {};

package/dist/types/query.d.ts

@@ -0,0 +1,7 @@
+import { operations } from '../../api-types/storeApiTypes.d.ts';
+import { QueryKey, UseQueryOptions } from '@tanstack/vue-query';
+import { OperationProp } from '@teamnovu/kit-shopware-api-client';
+export type OperationKey = keyof operations;
+export type OperationBody<Operations extends operations, K extends OperationKey> = OperationProp<Operations, K, 'body'>;
+export type OperationResponse<Operations extends operations, K extends OperationKey> = OperationProp<Operations, K, 'response'>;
+export type Options<Operations extends operations, K extends OperationKey, QK extends QueryKey = QueryKey> = UseQueryOptions<OperationResponse<Operations, K>, Error, OperationResponse<Operations, K>, OperationResponse<Operations, K>, QK>;

package/dist/usePagination.d.ts

@@ -0,0 +1,21 @@
+import { Schemas } from '../api-types/storeApiTypes.d.ts';
+import { MaybeRef, Ref, ComputedRef } from 'vue';
+interface PaginationOptions {
+    page?: MaybeRef<number>;
+    total?: MaybeRef<number>;
+    limit?: MaybeRef<number>;
+}
+export declare function usePagination(opts?: PaginationOptions): {
+    page: number;
+    total: Ref<number, number>;
+    limit: Ref<number | undefined, number | undefined>;
+    pageCount: ComputedRef<number>;
+    isLastPage: ComputedRef<boolean>;
+    isFirstPage: ComputedRef<boolean>;
+    usePaginationSync: (data: MaybeRef<Schemas["EntitySearchResult"]>) => void;
+    queryOptions: ComputedRef<{
+        p: number;
+        limit: number | undefined;
+    }>;
+};
+export {};

package/dist/util/url.d.ts

@@ -0,0 +1,2 @@
+export declare const relativizeSeoUrl: (seoUrl: string) => string;
+export declare const absolutizeSeoUrl: (seoUrl: string) => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamnovu/kit-shopware-composables",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "A collection of composables for the Shopware API",
   "main": "dist/index.mjs",
   "module": "dist/index.mjs",
@@ -13,14 +13,8 @@
   },
   "peerDependencies": {
     "@tanstack/vue-query": "^5.0.0",
-    "@teamnovu/kit-shopware-api-client": "workspace:*",
-    "vue": "^3.0.0"
-  },
-  "scripts": {
-    "build": "vite build",
-    "watch": "NODE_ENV=development vite build --watch",
-    "gen-types": "bash ./docker/types.sh",
-    "lint": "eslint --fix --ignore-pattern 'dist/**' ."
+    "vue": "^3.0.0",
+    "@teamnovu/kit-shopware-api-client": "0.0.3"
   },
   "repository": {
     "type": "git",
@@ -45,5 +39,11 @@
     "eslint-plugin-import": "^2.31.0",
     "typescript-eslint": "^8.30.1",
     "vitest": "^3.1.2"
+  },
+  "scripts": {
+    "build": "vite build",
+    "watch": "NODE_ENV=development vite build --watch",
+    "gen-types": "bash ./docker/types.sh",
+    "lint": "eslint --fix --ignore-pattern 'dist/**' ."
   }
 }

package/src/cart/useCartAddItemMutation.ts

@@ -0,0 +1,48 @@
+import { operations } from '#store-types'
+import { MutationOptions, useMutation, useQueryClient } from '@tanstack/vue-query'
+import { useShopwareQueryClient } from '../inject'
+import { cartKeys } from '../keys'
+import type { OperationBody, OperationKey, OperationResponse } from '../types/query'
+
+const addCartItemOperation = 'addLineItem post /checkout/cart/line-item' satisfies OperationKey
+
+type LineItem<Operations extends operations> = OperationBody<
+  Operations,
+  typeof addCartItemOperation
+>['items'][number]
+
+type LineItemPayload<Operations extends operations> =
+  Partial<Omit<LineItem<Operations>, 'id' | 'quantity' | 'type'>> &
+  Required<Pick<LineItem<Operations>, 'id' | 'quantity' | 'type'>>
+
+type Body<Operations extends operations> = Omit<
+  OperationBody<Operations, typeof addCartItemOperation>,
+  'items'
+> & {
+  items: LineItemPayload<Operations>[]
+}
+
+export function useCartAddItemMutation<Operations extends operations>(
+  mutationOptions: MutationOptions<
+    OperationResponse<Operations, typeof addCartItemOperation>,
+    unknown,
+    Body<Operations>
+  >,
+) {
+  const client = useShopwareQueryClient<Operations>()
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    ...mutationOptions,
+    mutationFn: async (body: Body<Operations>) => {
+      return client.query(addCartItemOperation, {
+        body: body as OperationBody<Operations, typeof addCartItemOperation>,
+      })
+    },
+    onSuccess: (newCart, variables, context) => {
+      queryClient.setQueryData(cartKeys.get(), newCart)
+      // queryClient.invalidateQueries({ queryKey: cartKeys.get() })
+      mutationOptions.onSuccess?.(newCart, variables, context)
+    },
+  })
+}

package/src/cart/useCartQueryOptions.ts

@@ -0,0 +1,19 @@
+import { operations } from '#store-types'
+import { queryOptions } from '@tanstack/vue-query'
+import { useShopwareQueryClient } from '../inject'
+import { cartKeys } from '../keys'
+import type { OperationKey } from '../types/query'
+
+const readCartOperation = 'readCart get /checkout/cart' satisfies OperationKey
+
+export function useCartQueryOptions<Operations extends operations>() {
+  const client = useShopwareQueryClient<Operations>()
+  const queryKey = cartKeys.get()
+
+  return queryOptions({
+    queryKey,
+    queryFn: async () => {
+      return client.query(readCartOperation)
+    },
+  })
+}

package/src/cart/useCartRemoveItemMutation.ts

@@ -0,0 +1,32 @@
+import { operations } from '#store-types'
+import { MutationOptions, useMutation, useQueryClient } from '@tanstack/vue-query'
+import { useShopwareQueryClient } from '../inject'
+import { cartKeys } from '../keys'
+import type { OperationBody, OperationKey, OperationResponse } from '../types/query'
+
+const removeCartItemOperation = 'removeLineItem post /checkout/cart/line-item/delete' satisfies OperationKey
+
+export function useCartRemoveItemMutation<Operations extends operations>(
+  mutationOptions?: MutationOptions<
+    OperationResponse<Operations, typeof removeCartItemOperation>,
+    unknown,
+    OperationBody<Operations, typeof removeCartItemOperation>
+  >,
+) {
+  const client = useShopwareQueryClient<Operations>()
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    ...mutationOptions,
+    mutationFn: async (body: OperationBody<Operations, typeof removeCartItemOperation>) => {
+      return client.query(removeCartItemOperation, {
+        body: body as OperationBody<Operations, typeof removeCartItemOperation>,
+      })
+    },
+    onSuccess: (newCart, variables, context) => {
+      queryClient.setQueryData(cartKeys.get(), newCart)
+      // queryClient.invalidateQueries({ queryKey: cartKeys.get() })
+      mutationOptions?.onSuccess?.(newCart, variables, context)
+    },
+  })
+}

package/src/cart/useCartUpdateItemMutation.ts

@@ -0,0 +1,48 @@
+import { operations } from '#store-types'
+import { MutationOptions, useMutation, useQueryClient } from '@tanstack/vue-query'
+import { useShopwareQueryClient } from '../inject'
+import { cartKeys } from '../keys'
+import type { OperationBody, OperationKey, OperationResponse } from '../types/query'
+
+const updateCartItemOperation = 'updateLineItem patch /checkout/cart/line-item' satisfies OperationKey
+
+type LineItem<Operations extends operations> = OperationBody<
+  Operations,
+  typeof updateCartItemOperation
+>['items'][number]
+
+type LineItemPayload<Operations extends operations> =
+  Partial<Omit<LineItem<Operations>, 'id' | 'quantity' | 'type'>> &
+  Required<Pick<LineItem<Operations>, 'id' | 'quantity' | 'type'>>
+
+type Body<Operations extends operations> = Omit<
+  OperationBody<Operations, typeof updateCartItemOperation>,
+  'items'
+> & {
+  items: LineItemPayload<Operations>[]
+}
+
+export function useCartUpdateItemMutation<Operations extends operations>(
+  mutationOptions?: MutationOptions<
+    OperationResponse<Operations, typeof updateCartItemOperation>,
+    unknown,
+    Body<Operations>
+  >,
+) {
+  const client = useShopwareQueryClient<Operations>()
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    ...mutationOptions,
+    mutationFn: async (body: Body<Operations>) => {
+      return client.query(updateCartItemOperation, {
+        body: body as OperationBody<Operations, typeof updateCartItemOperation>,
+      })
+    },
+    onSuccess: (newCart, variables, context) => {
+      queryClient.setQueryData(cartKeys.get(), newCart)
+      // queryClient.invalidateQueries({ queryKey: cartKeys.get() })
+      mutationOptions?.onSuccess?.(newCart, variables, context)
+    },
+  })
+}

package/src/index.ts

@@ -1,4 +1,8 @@
 import type { Schemas as BaseSchemas, operations } from '#store-types'
+import { useCartAddItemMutation } from './cart/useCartAddItemMutation'
+import { useCartQueryOptions } from './cart/useCartQueryOptions'
+import { useCartRemoveItemMutation } from './cart/useCartRemoveItemMutation'
+import { useCartUpdateItemMutation } from './cart/useCartUpdateItemMutation'
 import { useContextOptions } from './context/useContextOptions'
 import { useContextUpdate } from './context/useContextUpdate'
 import { useCategoryQueryOptions } from './products/useCategoryQueryOptions'
@@ -21,4 +25,8 @@ export default class ShopwareComposables<Operations extends operations, Schemas
   useContextUpdate = useContextUpdate<Operations>
   useProductQueryOptions = useProductQueryOptions<Operations>
   useProductVariantForOptions = useProductVariantForOptions<Schemas>
+  useCartQueryOptions = useCartQueryOptions<Operations>
+  useCartUpdateItemMutation = useCartUpdateItemMutation<Operations>
+  useCartRemoveItemMutation = useCartRemoveItemMutation<Operations>
+  useCartAddItemMutation = useCartAddItemMutation<Operations>
 }

package/src/keys.ts

@@ -40,3 +40,7 @@ export const productKeys = {
       },
     ] as const,
 }
+
+export const cartKeys = {
+  get: () => ['cart'] as const,
+}