@myparcel-dev/pdk-admin 1.13.0

package/src/actions/composables/mutations/account/useUpdateAccountMutation.ts

@@ -0,0 +1,60 @@
+import {useQueryClient} from '@tanstack/vue-query';
+import {AdminContextKey, BackendEndpoint, Variant} from '@myparcel-dev/pdk-common';
+import {isOfType} from '@myparcel-dev/ts-utils';
+import {type ApiException} from '@myparcel-dev/sdk';
+import {usePdkMutation} from '../usePdkMutation';
+import {formToBody} from '../../../../utils';
+import {type ActionInput} from '../../../../types';
+import {type ResolvedQuery, useNotificationStore} from '../../../../stores';
+import {usePdkAdminApi} from '../../../../sdk';
+import {NotificationCategory} from '../../../../data';
+import {useLanguage} from '../../../../composables';
+
+export const useUpdateAccountMutation = (): ResolvedQuery<BackendEndpoint.UpdateAccount> => {
+  const queryClient = useQueryClient();
+  const defaultMutationOptions = queryClient.defaultMutationOptions();
+  const {translate} = useLanguage();
+
+  return usePdkMutation(
+    BackendEndpoint.UpdateAccount,
+    async (input) => {
+      const pdk = usePdkAdminApi();
+
+      const response = await pdk.updateAccount({body: formToBody(input?.form)});
+
+      return response[0];
+    },
+    {
+      ...defaultMutationOptions,
+
+      onSuccess(data) {
+        queryClient.setQueryData(
+          [BackendEndpoint.FetchContext, AdminContextKey.Dynamic],
+          data[AdminContextKey.Dynamic],
+        );
+
+        queryClient.setQueryData(
+          [BackendEndpoint.FetchContext, AdminContextKey.PluginSettingsView],
+          data[AdminContextKey.PluginSettingsView],
+        );
+      },
+
+      onError(error, variables: ActionInput<BackendEndpoint.UpdateAccount>, context) {
+        if (!isOfType<ApiException>(error, 'data')) {
+          defaultMutationOptions.onError?.(error, variables, context);
+        }
+
+        const notificationStore = useNotificationStore();
+        const translation = 'error_invalid_api_key';
+
+        notificationStore.add({
+          category: NotificationCategory.General,
+          content: translate(`${translation}_content`),
+          title: translate(translation),
+          timeout: false,
+          variant: Variant.Error,
+        });
+      },
+    },
+  );
+};

package/src/actions/composables/mutations/debug/index.ts

@@ -0,0 +1,3 @@
+export * from './useDownloadLogsMutation';
+export * from './useSwitchToAcceptanceApiMutation';
+export * from './useSwitchToProductionApiMutation';

package/src/actions/composables/mutations/debug/useDownloadLogsMutation.ts

@@ -0,0 +1,8 @@
+import {BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {usePdkMutation} from '../usePdkMutation';
+import {type ResolvedQuery} from '../../../../stores';
+import {usePdkAdminApi} from '../../../../sdk';
+
+export const useDownloadLogsMutation = (): ResolvedQuery<BackendEndpoint.DownloadLogs> => {
+  return usePdkMutation(BackendEndpoint.DownloadLogs, () => usePdkAdminApi().downloadLogs());
+};

package/src/actions/composables/mutations/debug/useSwitchToAcceptanceApiMutation.ts

@@ -0,0 +1,10 @@
+import {BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {usePdkMutation} from '../usePdkMutation';
+import {type ResolvedQuery} from '../../../../stores';
+import {usePdkAdminApi} from '../../../../sdk';
+
+export const useSwitchToAcceptanceApiMutation = (): ResolvedQuery<BackendEndpoint.SwitchToAcceptanceApi> => {
+  return usePdkMutation(BackendEndpoint.SwitchToAcceptanceApi, () =>
+    (usePdkAdminApi() as {switchToAcceptanceApi: () => Promise<void>}).switchToAcceptanceApi(),
+  );
+};

package/src/actions/composables/mutations/debug/useSwitchToProductionApiMutation.ts

@@ -0,0 +1,10 @@
+import {BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {usePdkMutation} from '../usePdkMutation';
+import {type ResolvedQuery} from '../../../../stores';
+import {usePdkAdminApi} from '../../../../sdk';
+
+export const useSwitchToProductionApiMutation = (): ResolvedQuery<BackendEndpoint.SwitchToProductionApi> => {
+  return usePdkMutation(BackendEndpoint.SwitchToProductionApi, () =>
+    (usePdkAdminApi() as {switchToProductionApi: () => Promise<void>}).switchToProductionApi(),
+  );
+};

package/src/actions/composables/mutations/index.ts

@@ -0,0 +1,7 @@
+export * from './account';
+export * from './debug';
+export * from './orders';
+export * from './settings';
+export * from './shipments';
+export * from './usePdkMutation';
+export * from './webhooks';

package/src/actions/composables/mutations/orders/index.ts

@@ -0,0 +1,3 @@
+export * from './useExportOrdersMutation';
+export * from './usePrintOrdersMutation';
+export * from './useUpdateOrdersMutation';

package/src/actions/composables/mutations/orders/useExportOrdersMutation.ts

@@ -0,0 +1,51 @@
+import {useQueryClient} from '@tanstack/vue-query';
+import {BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {type OneOrMore, toArray} from '@myparcel-dev/ts-utils';
+import {usePdkMutation} from '../usePdkMutation';
+import {encodeArrayParameter, formToBody} from '../../../../utils';
+import {type BackendEndpointOptions} from '../../../../types';
+import {type ResolvedQuery, useModalStore} from '../../../../stores';
+import {getCallbackForMutationMode, getModalMutationOptions, MutationMode} from '../../../../services';
+import {usePdkAdminApi} from '../../../../sdk';
+import {fillShipmentsQueryData} from '../../../../pdk';
+
+export const useExportOrdersMutation = (
+  orderIds?: OneOrMore<string>,
+  mode: MutationMode = MutationMode.Default,
+): ResolvedQuery<BackendEndpoint.ExportOrders> => {
+  const queryClient = useQueryClient();
+
+  return usePdkMutation(
+    BackendEndpoint.ExportOrders,
+    async (input) => {
+      const pdk = usePdkAdminApi();
+      getCallbackForMutationMode(mode)?.();
+
+      const options: BackendEndpointOptions<BackendEndpoint.ExportOrders> = {
+        parameters: {
+          orderIds: encodeArrayParameter(orderIds),
+        },
+        body: [formToBody(input.form)],
+      };
+
+      // @ts-expect-error custom endpoints are not typed correctly
+      return pdk.exportOrders(options);
+    },
+    {
+      ...queryClient.defaultMutationOptions(),
+      ...(mode === MutationMode.Modal ? getModalMutationOptions() : {}),
+
+      async onSuccess(data, input) {
+        useModalStore().close();
+
+        toArray(data).forEach((order) => {
+          fillShipmentsQueryData(queryClient, order.shipments?.slice(-1) ?? [], order);
+        });
+
+        if (input.form) {
+          await input.form?.reset();
+        }
+      },
+    },
+  );
+};

package/src/actions/composables/mutations/orders/usePrintOrdersMutation.ts

@@ -0,0 +1,23 @@
+import {BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {type OneOrMore} from '@myparcel-dev/ts-utils';
+import {usePdkMutation} from '../usePdkMutation';
+import {encodeArrayParameter} from '../../../../utils';
+import {type ResolvedQuery} from '../../../../stores';
+import {usePdkAdminApi} from '../../../../sdk';
+
+export const usePrintOrdersMutation = (orderIds?: OneOrMore<string>): ResolvedQuery<BackendEndpoint.PrintOrders> => {
+  return usePdkMutation(BackendEndpoint.PrintOrders, (input) => {
+    const pdk = usePdkAdminApi();
+
+    return pdk.printOrders({
+      // @ts-expect-error custom endpoints are not typed correctly
+      parameters: {
+        format: input.format,
+        output: input.output,
+        position: input.position,
+        // Input is used instead of orderIds parameter when bulk printing
+        orderIds: encodeArrayParameter(orderIds ?? input.orderIds),
+      },
+    });
+  });
+};

package/src/actions/composables/mutations/orders/useUpdateOrdersMutation.ts

@@ -0,0 +1,36 @@
+import {useQueryClient} from '@tanstack/vue-query';
+import {BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {type OneOrMore, toArray} from '@myparcel-dev/ts-utils';
+import {usePdkMutation} from '../usePdkMutation';
+import {encodeArrayParameter, formToBody, setQueryOrder} from '../../../../utils';
+import {type BackendEndpointOptions} from '../../../../types';
+import {type ResolvedQuery} from '../../../../stores';
+import {usePdkAdminApi} from '../../../../sdk';
+
+export const useUpdateOrdersMutation = (orderIds?: OneOrMore<string>): ResolvedQuery<BackendEndpoint.UpdateOrders> => {
+  const queryClient = useQueryClient();
+  const pdk = usePdkAdminApi();
+
+  return usePdkMutation(
+    BackendEndpoint.UpdateOrders,
+    async (input) => {
+      const options: BackendEndpointOptions<BackendEndpoint.UpdateOrders> = {
+        parameters: {
+          orderIds: encodeArrayParameter(orderIds),
+        },
+        body: [formToBody(input.form)],
+      };
+
+      // @ts-expect-error custom endpoints are not typed correctly
+      return pdk.updateOrders(options);
+    },
+    {
+      ...queryClient.defaultMutationOptions(),
+      onSuccess(orders) {
+        toArray(orders).forEach((order) => {
+          setQueryOrder(queryClient, order);
+        });
+      },
+    },
+  );
+};

package/src/actions/composables/mutations/settings/index.ts

@@ -0,0 +1,2 @@
+export * from './useUpdatePluginSettingsMutation';
+export * from './useUpdateProductSettingsMutation';

package/src/actions/composables/mutations/settings/useUpdatePluginSettingsMutation.ts

@@ -0,0 +1,16 @@
+import {BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {usePdkMutation} from '../usePdkMutation';
+import {formToBody} from '../../../../utils';
+import {type ResolvedQuery} from '../../../../stores';
+import {usePdkAdminApi} from '../../../../sdk';
+
+export const useUpdatePluginSettingsMutation = (): ResolvedQuery<BackendEndpoint.UpdatePluginSettings> => {
+  return usePdkMutation(BackendEndpoint.UpdatePluginSettings, ({form}) => {
+    const pdk = usePdkAdminApi();
+
+    return pdk.updatePluginSettings({
+      // @ts-expect-error todo
+      body: formToBody(form),
+    });
+  });
+};

package/src/actions/composables/mutations/settings/useUpdateProductSettingsMutation.ts

@@ -0,0 +1,22 @@
+import {BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {usePdkMutation} from '../usePdkMutation';
+import {type ResolvedQuery} from '../../../../stores';
+import {usePdkAdminApi} from '../../../../sdk';
+
+export const useUpdateProductSettingsMutation = (): ResolvedQuery<BackendEndpoint.UpdateProductSettings> => {
+  return usePdkMutation(BackendEndpoint.UpdateProductSettings, ({form, productIds}) => {
+    const pdk = usePdkAdminApi();
+
+    const options = {
+      params: {
+        productIds,
+      },
+      body: {
+        [form.name]: form.getValues(),
+      },
+    };
+
+    // @ts-expect-error custom endpoints are not typed correctly
+    return pdk.updateProductSettings(options);
+  });
+};

package/src/actions/composables/mutations/shipments/index.ts

@@ -0,0 +1,4 @@
+export * from './useDeleteShipmentsMutation';
+export * from './useExportReturnMutation';
+export * from './usePrintShipmentsMutation';
+export * from './useUpdateShipmentsMutation';

package/src/actions/composables/mutations/shipments/useDeleteShipmentsMutation.ts

@@ -0,0 +1,65 @@
+import {type QueryKey, useMutation, useQueryClient} from '@tanstack/vue-query';
+import {type BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {type OneOrMore, toArray} from '@myparcel-dev/ts-utils';
+import {QUERY_KEY_ORDER, QUERY_KEY_SHIPMENT} from '../../queries';
+import {encodeArrayParameter, setQueryOrder} from '../../../../utils';
+import {type ActionInput, type BackendEndpointResponse} from '../../../../types';
+import {type ResolvedQuery} from '../../../../stores';
+import {usePdkAdminApi} from '../../../../sdk';
+
+// eslint-disable-next-line max-lines-per-function
+export const useDeleteShipmentsMutation = (
+  orderIds?: OneOrMore<string>,
+  shipmentIds?: OneOrMore<number>,
+): ResolvedQuery<BackendEndpoint.DeleteShipments> => {
+  const queryClient = useQueryClient();
+  const pdk = usePdkAdminApi();
+
+  return useMutation(
+    [QUERY_KEY_SHIPMENT, {orderIds, shipmentIds}],
+    async () => {
+      return pdk.deleteShipments({
+        // @ts-expect-error custom endpoints are not typed correctly
+        parameters: {
+          orderIds: encodeArrayParameter(orderIds),
+          shipmentIds: encodeArrayParameter(shipmentIds),
+        },
+      });
+    },
+    {
+      ...queryClient.defaultMutationOptions(),
+
+      async onMutate(input: ActionInput<BackendEndpoint.DeleteShipments>) {
+        const previousValues: {queryKey: QueryKey; value: unknown}[] = [];
+        const orderIds = toArray(input.orderIds).map(String);
+        const shipmentIds = toArray(input.shipmentIds).map(Number);
+
+        await Promise.all(
+          orderIds.map(async (orderId) => {
+            const queryKey = [QUERY_KEY_ORDER, {id: orderId}] as const;
+            await queryClient.cancelQueries({queryKey});
+
+            const previousOrder = queryClient.getQueryData(
+              queryKey,
+            ) as BackendEndpointResponse<BackendEndpoint.FetchOrders>;
+
+            previousValues.push({queryKey, value: previousOrder});
+
+            setQueryOrder(queryClient, {
+              ...previousOrder,
+              shipments: previousOrder.shipments.filter((shipment) => !shipmentIds.includes(shipment.id)),
+            });
+          }),
+        );
+
+        return {previousValues};
+      },
+
+      onError(err, item, context) {
+        context?.previousValues.forEach(({queryKey, value}) => {
+          queryClient.setQueryData(queryKey, value);
+        });
+      },
+    },
+  );
+};

package/src/actions/composables/mutations/shipments/useExportReturnMutation.ts

@@ -0,0 +1,36 @@
+import {useMutation, useQueryClient} from '@tanstack/vue-query';
+import {type BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {type OneOrMore, toArray} from '@myparcel-dev/ts-utils';
+import {QUERY_KEY_SHIPMENT} from '../../queries';
+import {encodeArrayParameter, setQueryOrder} from '../../../../utils';
+import {type ResolvedQuery} from '../../../../stores';
+import {usePdkAdminApi} from '../../../../sdk';
+
+export const useExportReturnMutation = (
+  orderIds?: OneOrMore<string>,
+  shipmentIds?: OneOrMore<number>,
+): ResolvedQuery<BackendEndpoint.ExportReturn> => {
+  const queryClient = useQueryClient();
+
+  return useMutation(
+    [QUERY_KEY_SHIPMENT, {orderIds, shipmentIds}],
+    () => {
+      const pdk = usePdkAdminApi();
+
+      return pdk.exportReturn({
+        // @ts-expect-error todo
+        parameters: {
+          orderIds: encodeArrayParameter(orderIds),
+          shipmentIds: encodeArrayParameter(shipmentIds),
+        },
+      });
+    },
+    {
+      onSuccess: (data) => {
+        toArray(data).forEach((order) => {
+          setQueryOrder(queryClient, order);
+        });
+      },
+    },
+  );
+};

package/src/actions/composables/mutations/shipments/usePrintShipmentsMutation.ts

@@ -0,0 +1,39 @@
+import {useMutation} from '@tanstack/vue-query';
+import {type BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {type OneOrMore} from '@myparcel-dev/ts-utils';
+import {QUERY_KEY_SHIPMENT} from '../../queries';
+import {encodeArrayParameter} from '../../../../utils';
+import {type ResolvedQuery} from '../../../../stores';
+import {usePdkAdminApi} from '../../../../sdk';
+import {usePluginSettings} from '../../../../composables';
+
+export const usePrintShipmentsMutation = (
+  orderIds?: OneOrMore<string>,
+  shipmentIds?: OneOrMore<number>,
+): ResolvedQuery<BackendEndpoint.PrintShipments> => {
+  return useMutation(
+    [
+      QUERY_KEY_SHIPMENT,
+      {
+        orderIds,
+        shipmentIds,
+      },
+    ],
+    async (input) => {
+      const pdk = usePdkAdminApi();
+      const pluginSettings = usePluginSettings();
+
+      return pdk.printShipments({
+        // @ts-expect-error todo
+        parameters: {
+          format: pluginSettings.label.format,
+          output: pluginSettings.label.output,
+          position: pluginSettings.label.position,
+          // Input is used instead of parameters when bulk printing
+          orderIds: encodeArrayParameter(orderIds ?? input.orderIds),
+          shipmentIds: encodeArrayParameter(shipmentIds ?? input.shipmentIds),
+        },
+      });
+    },
+  );
+};

package/src/actions/composables/mutations/shipments/useUpdateShipmentsMutation.ts

@@ -0,0 +1,36 @@
+import {useMutation, useQueryClient} from '@tanstack/vue-query';
+import {type BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {type OneOrMore} from '@myparcel-dev/ts-utils';
+import {QUERY_KEY_SHIPMENT} from '../../queries';
+import {encodeArrayParameter} from '../../../../utils';
+import {type ResolvedQuery} from '../../../../stores';
+import {usePdkAdminApi} from '../../../../sdk';
+import {fillShipmentsQueryData} from '../../../../pdk';
+
+export const useUpdateShipmentsMutation = (
+  orderIds?: OneOrMore<string>,
+  shipmentIds?: OneOrMore<number>,
+): ResolvedQuery<BackendEndpoint.UpdateShipments> => {
+  const queryClient = useQueryClient();
+
+  return useMutation(
+    [QUERY_KEY_SHIPMENT, {orderIds, shipmentIds}],
+    () => {
+      const pdk = usePdkAdminApi();
+
+      return pdk.updateShipments({
+        // @ts-expect-error todo
+        parameters: {
+          orderIds: encodeArrayParameter(orderIds),
+          shipmentIds: encodeArrayParameter(shipmentIds),
+        },
+      });
+    },
+    {
+      ...queryClient.defaultMutationOptions(),
+      onSuccess: (data) => {
+        fillShipmentsQueryData(queryClient, data);
+      },
+    },
+  );
+};

package/src/actions/composables/mutations/usePdkMutation.ts

@@ -0,0 +1,41 @@
+import {type MaybeRef} from '@vueuse/core';
+import {useMutation, type UseMutationOptions, type UseMutationReturnType} from '@tanstack/vue-query';
+import {type MutationFunction} from '@tanstack/query-core';
+import {type BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {type ApiException} from '@myparcel-dev/sdk';
+import {type ActionInput, type BackendEndpointResponse} from '../../../types';
+
+type MaybeRefDeep<T> = MaybeRef<
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  T extends Function
+    ? T
+    : T extends object
+    ? {
+        [Property in keyof T]: MaybeRefDeep<T[Property]>;
+      }
+    : T
+>;
+
+type VueMutationObserverOptions<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> = {
+  [Property in keyof UseMutationOptions<TData, TError, TVariables, TContext>]: MaybeRefDeep<
+    UseMutationOptions<TData, TError, TVariables, TContext>[Property]
+  >;
+};
+
+type UsePdkMutation = <
+  E extends BackendEndpoint,
+  TData extends BackendEndpointResponse<E> = BackendEndpointResponse<E>,
+  TError extends ApiException = ApiException,
+  TVariables extends ActionInput<E> = ActionInput<E>,
+  TContext = unknown,
+>(
+  endpoint: E,
+  mutationFn: MaybeRef<MutationFunction<TData, TVariables>>,
+  options?: MaybeRef<
+    Omit<VueMutationObserverOptions<TData, TError, TVariables, TContext>, 'mutationKey' | 'mutationFn'>
+  >,
+) => UseMutationReturnType<TData, TError, TVariables, TContext>;
+
+export const usePdkMutation: UsePdkMutation = (endpoint, mutationFn, options) => {
+  return useMutation([endpoint], mutationFn, options);
+};

package/src/actions/composables/mutations/webhooks/index.ts

@@ -0,0 +1,2 @@
+export * from './useCreateWebhooksMutation';
+export * from './useDeleteWebhooksMutation';

package/src/actions/composables/mutations/webhooks/useCreateWebhooksMutation.ts

@@ -0,0 +1,20 @@
+import {useQueryClient} from '@tanstack/vue-query';
+import {BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {usePdkMutation} from '../usePdkMutation';
+import {usePdkAdminApi} from '../../../../sdk';
+
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+export const useCreateWebhooksMutation = () => {
+  const queryClient = useQueryClient();
+
+  return usePdkMutation(
+    BackendEndpoint.CreateWebhooks,
+    (input) => usePdkAdminApi().createWebhooks({parameters: input}),
+    {
+      ...queryClient.defaultMutationOptions(),
+      onSuccess: (data) => {
+        queryClient.setQueryData([BackendEndpoint.FetchWebhooks], data);
+      },
+    },
+  );
+};

package/src/actions/composables/mutations/webhooks/useDeleteWebhooksMutation.ts

@@ -0,0 +1,20 @@
+import {useQueryClient} from '@tanstack/vue-query';
+import {BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {usePdkMutation} from '../usePdkMutation';
+import {type ResolvedQuery} from '../../../../stores';
+import {usePdkAdminApi} from '../../../../sdk';
+
+export const useDeleteWebhooksMutation = (): ResolvedQuery<BackendEndpoint.DeleteWebhooks> => {
+  const queryClient = useQueryClient();
+
+  return usePdkMutation(
+    BackendEndpoint.DeleteWebhooks,
+    (input) => usePdkAdminApi().deleteWebhooks({parameters: input}),
+    {
+      ...queryClient.defaultMutationOptions(),
+      onSuccess: (data) => {
+        queryClient.setQueryData([BackendEndpoint.FetchWebhooks], data);
+      },
+    },
+  );
+};

package/src/actions/composables/queries/account/index.ts

@@ -0,0 +1 @@
+export * from './useFetchContextQuery';

package/src/actions/composables/queries/account/useFetchContextQuery.ts

@@ -0,0 +1,43 @@
+import {useQuery, useQueryClient} from '@tanstack/vue-query';
+import {AdminContextKey, BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {encodeArrayParameter} from '../../../../utils';
+import {type ResolvedQuery} from '../../../../stores';
+import {usePdkAdminApi} from '../../../../sdk';
+import {AdminView} from '../../../../data';
+import {useAdminInstance} from '../../../../composables';
+
+export const useFetchContextQuery = <C extends AdminContextKey = AdminContextKey.Dynamic>(
+  contextKey?: C,
+): ResolvedQuery<BackendEndpoint.FetchContext> => {
+  const queryClient = useQueryClient();
+  const adminInstance = useAdminInstance();
+
+  contextKey ??= AdminContextKey.Dynamic as C;
+
+  return useQuery(
+    [BackendEndpoint.FetchContext, contextKey],
+    async () => {
+      const pdk = usePdkAdminApi();
+      const context = await pdk.fetchContext({
+        // @ts-expect-error custom endpoints are not typed correctly
+        parameters: {
+          context: encodeArrayParameter(contextKey),
+        },
+      });
+
+      return context[0][contextKey] ?? {};
+    },
+    {
+      ...queryClient.defaultQueryOptions(),
+      // Refetch dynamic context on window focus if the current view is not the plugin settings view.
+      refetchOnWindowFocus: (query) => {
+        return adminInstance.view !== AdminView.PluginSettings && query.queryKey[1] === AdminContextKey.Dynamic
+          ? 'always'
+          : false;
+      },
+      onSuccess: (data) => {
+        queryClient.setQueryData([BackendEndpoint.FetchContext, contextKey], data);
+      },
+    },
+  );
+};

package/src/actions/composables/queries/index.ts

@@ -0,0 +1,6 @@
+export * from './account';
+export * from './orders';
+export * from './products';
+export * from './queryKeys';
+export * from './shipments';
+export * from './webhooks';

package/src/actions/composables/queries/orders/index.ts

@@ -0,0 +1 @@
+export * from './useFetchOrdersQuery';

package/src/actions/composables/queries/orders/useFetchOrdersQuery.ts

@@ -0,0 +1,35 @@
+import {type QueryKey, useQuery, useQueryClient} from '@tanstack/vue-query';
+import {type BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {toArray} from '@myparcel-dev/ts-utils';
+import {QUERY_KEY_ORDER} from '../queryKeys';
+import {encodeArrayParameter} from '../../../../utils';
+import {type ResolvedQuery} from '../../../../stores';
+import {usePdkAdminApi} from '../../../../sdk';
+import {fillShipmentsQueryData} from '../../../../pdk';
+
+export const useFetchOrdersQuery = (externalIdentifier?: string): ResolvedQuery<BackendEndpoint.FetchOrders> => {
+  const queryKey: QueryKey = [QUERY_KEY_ORDER, ...(externalIdentifier ? [{id: externalIdentifier}] : [])] as const;
+  const queryClient = useQueryClient();
+
+  return useQuery(
+    queryKey,
+    () => {
+      const pdk = usePdkAdminApi();
+
+      return pdk.fetchOrders({
+        // @ts-expect-error custom endpoints are not typed correctly
+        parameters: {
+          orderIds: encodeArrayParameter(externalIdentifier),
+        },
+      });
+    },
+    {
+      ...queryClient.defaultQueryOptions(),
+      onSuccess: (data) => {
+        toArray(data).forEach((order) => {
+          fillShipmentsQueryData(queryClient, order.shipments, order);
+        });
+      },
+    },
+  );
+};

package/src/actions/composables/queries/products/index.ts

@@ -0,0 +1 @@
+export * from './useFetchProductsQuery';