@myparcel-dev/pdk-admin 1.13.0

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

@@ -0,0 +1,20 @@
+import {type QueryKey, useQuery, useQueryClient} from '@tanstack/vue-query';
+import {BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {type ResolvedQuery} from '../../../../stores';
+
+export const useFetchProductsQuery = (externalIdentifier?: string): ResolvedQuery<BackendEndpoint.FetchProducts> => {
+  const queryKey: QueryKey = [
+    BackendEndpoint.FetchProducts,
+    ...(externalIdentifier ? [{id: externalIdentifier}] : []),
+  ] as const;
+
+  const queryClient = useQueryClient();
+
+  return useQuery(
+    queryKey,
+    () => {
+      throw new Error('Not implemented');
+    },
+    queryClient.defaultQueryOptions(),
+  );
+};

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

@@ -0,0 +1,3 @@
+export const QUERY_KEY_ORDER = 'order';
+
+export const QUERY_KEY_SHIPMENT = 'shipment';

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

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

package/src/actions/composables/queries/shipments/useFetchShipmentsQuery.ts

@@ -0,0 +1,44 @@
+import {type QueryKey, useQuery, useQueryClient} from '@tanstack/vue-query';
+import {type BackendEndpoint, type Shipment} from '@myparcel-dev/pdk-common';
+import {type OneOrMore, toArray} from '@myparcel-dev/ts-utils';
+import {QUERY_KEY_SHIPMENT} from '../queryKeys';
+import {encodeArrayParameter} from '../../../../utils';
+import {type BackendEndpointResponse} from '../../../../types';
+import {type ResolvedQuery} from '../../../../stores';
+import {usePdkAdminApi} from '../../../../sdk';
+import {fillShipmentsQueryData} from '../../../../pdk';
+
+export const useFetchShipmentsQuery = <I extends number>(
+  orderIds?: OneOrMore<string>,
+  shipmentIds?: I,
+): ResolvedQuery<BackendEndpoint.FetchShipments> => {
+  const queryKey: QueryKey = [QUERY_KEY_SHIPMENT, ...(shipmentIds ? [{id: shipmentIds}] : [])] as const;
+  const queryClient = useQueryClient();
+
+  return useQuery(
+    queryKey,
+    async () => {
+      const pdk = usePdkAdminApi();
+
+      const orders = (await pdk.fetchOrders({
+        // @ts-expect-error custom endpoints are not typed correctly
+        parameters: {
+          orderIds: encodeArrayParameter(orderIds),
+        },
+      })) as BackendEndpointResponse<BackendEndpoint.FetchOrders>;
+
+      return toArray(orders).reduce((acc, order) => {
+        const shipment = order.shipments?.find((shipment) => shipment.id === shipmentIds);
+
+        return shipment ?? acc;
+      }, undefined as Shipment.ModelShipment | undefined);
+    },
+    // @ts-expect-error todo
+    {
+      ...queryClient.defaultQueryOptions(),
+      onSuccess(data) {
+        fillShipmentsQueryData(queryClient, data);
+      },
+    },
+  );
+};

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

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

package/src/actions/composables/queries/webhooks/useFetchWebhooksQuery.ts

@@ -0,0 +1,24 @@
+import {useQuery, useQueryClient} from '@tanstack/vue-query';
+import {BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {type ResolvedQuery} from '../../../../stores';
+import {usePdkAdminApi} from '../../../../sdk';
+
+export const useFetchWebhooksQuery = (): ResolvedQuery<BackendEndpoint.FetchWebhooks> => {
+  const queryKey = [BackendEndpoint.FetchWebhooks] as const;
+  const queryClient = useQueryClient();
+
+  return useQuery(
+    queryKey,
+    () => {
+      const pdk = usePdkAdminApi();
+
+      return pdk.fetchWebhooks();
+    },
+    {
+      ...queryClient.defaultQueryOptions(),
+      onSuccess: (data) => {
+        queryClient.setQueryData(queryKey, data);
+      },
+    },
+  );
+};

package/src/actions/defineAction.ts

@@ -0,0 +1,10 @@
+import {type GenericActionDefinition, type NamedActionDefinition} from '../types';
+import {type AdminAction} from '../data';
+
+type DefineAction = {
+  <A extends AdminAction>(input: NamedActionDefinition<A>): NamedActionDefinition<A>;
+  <D extends GenericActionDefinition>(input: D): D;
+};
+
+// @ts-expect-error todo
+export const defineAction: DefineAction = (input) => input;

package/src/actions/definitions/account.ts

@@ -0,0 +1,39 @@
+import {AdminContextKey, BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {createMutationHandler} from '../executors';
+import {defineAction} from '../defineAction';
+import {AdminAction, AdminIcon} from '../../data';
+
+/**
+ * Update account.
+ */
+export const updateAccountAction = defineAction({
+  name: AdminAction.AccountUpdate,
+  icon: AdminIcon.Save,
+  label: 'action_save',
+  handler: createMutationHandler(BackendEndpoint.UpdateAccount),
+  afterHandle(context) {
+    if (!context.response?.[AdminContextKey.Dynamic]?.account) {
+      context.instance.logger.error('Account not found');
+    }
+
+    return context.response;
+  },
+});
+
+/**
+ * Refresh account.
+ */
+export const refreshAccountAction = defineAction({
+  ...updateAccountAction,
+  label: 'action_update_account',
+});
+
+/**
+ * Delete account.
+ */
+export const deleteAccountAction = defineAction({
+  name: AdminAction.AccountDelete,
+  icon: AdminIcon.Delete,
+  label: 'action_delete',
+  handler: createMutationHandler(BackendEndpoint.DeleteAccount),
+});

package/src/actions/definitions/context.ts

@@ -0,0 +1,17 @@
+import {AdminContextKey, BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {createQueryHandler} from '../executors';
+import {defineAction} from '../defineAction';
+import {AdminAction} from '../../data';
+
+/**
+ * Retrieve context.
+ */
+export const fetchDynamicContextAction = defineAction({
+  name: AdminAction.ContextFetch,
+  handler: createQueryHandler(BackendEndpoint.FetchContext, AdminContextKey.Dynamic),
+});
+
+export const fetchPluginSettingsViewContextAction = defineAction({
+  name: AdminAction.ContextFetch,
+  handler: createQueryHandler(BackendEndpoint.FetchContext, AdminContextKey.PluginSettingsView),
+});

package/src/actions/definitions/debug.ts

@@ -0,0 +1,39 @@
+import {BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {createMutationHandler} from '../executors';
+import {defineAction} from '../defineAction';
+import {downloadBlob} from '../../utils/downloadBlob';
+import {AdminAction, AdminIcon} from '../../data';
+
+/**
+ * Download zip with logs.
+ */
+export const downloadLogsAction = defineAction({
+  name: AdminAction.DownloadLogs,
+  icon: AdminIcon.Download,
+  label: 'action_download_logs',
+  handler: createMutationHandler(BackendEndpoint.DownloadLogs),
+  // @ts-expect-error todo
+  afterHandle(response) {
+    downloadBlob(response.response, 'logs.zip');
+  },
+});
+
+/**
+ * Switch to acceptance API.
+ */
+export const switchToAcceptanceApiAction = defineAction({
+  name: AdminAction.SwitchToAcceptanceApi,
+  icon: AdminIcon.Refresh,
+  label: 'action_switch_to_acceptance_api',
+  handler: createMutationHandler(BackendEndpoint.SwitchToAcceptanceApi),
+});
+
+/**
+ * Switch to production API.
+ */
+export const switchToProductionApiAction = defineAction({
+  name: AdminAction.SwitchToProductionApi,
+  icon: AdminIcon.Refresh,
+  label: 'action_switch_to_production_api',
+  handler: createMutationHandler(BackendEndpoint.SwitchToProductionApi),
+});

package/src/actions/definitions/index.ts

@@ -0,0 +1,8 @@
+export * from './account';
+export * from './context';
+export * from './debug';
+export * from './modal';
+export * from './orders';
+export * from './settings';
+export * from './shipments';
+export * from './webhooks';

package/src/actions/definitions/modal.ts

@@ -0,0 +1,32 @@
+import {executeNextAction} from '../executors';
+import {defineAction} from '../defineAction';
+import {useModalStore} from '../../stores';
+
+/**
+ * Close current modal.
+ */
+export const modalCloseAction = defineAction({
+  id: 'modal_close',
+  label: 'action_close',
+  handler() {
+    const modalStore = useModalStore();
+
+    modalStore.close();
+  },
+});
+
+/**
+ * Trigger a submit on the form in the current modal context.
+ */
+export const modalSubmitFormAction = defineAction({
+  id: 'modal_submit',
+  label: 'action_submit',
+  async handler() {
+    const modalStore = useModalStore();
+
+    await modalStore.context?.form?.submit();
+  },
+  async afterHandle(context) {
+    await executeNextAction(context, modalCloseAction);
+  },
+});

package/src/actions/definitions/orders.ts

@@ -0,0 +1,128 @@
+import {BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {toArray} from '@myparcel-dev/ts-utils';
+import {openOrPrintPdf, resolvePrintParameters} from '../print';
+import {createOrdersMutationHandler, createQueryHandler, executeNextAction, resolveOrderParameters} from '../executors';
+import {defineAction} from '../defineAction';
+import {getOrderShipmentIds} from '../../utils';
+import {type OrderIds} from '../../types';
+import {useModalStore} from '../../stores';
+import {AdminAction, AdminIcon, AdminModalKey} from '../../data';
+import {shipmentsUpdateAction} from './shipments';
+import {useGlobalContext} from '../../composables/context/useGlobalContext';
+
+/**
+ * Open modal to edit order shipment options.
+ */
+export const ordersEditAction = defineAction({
+  name: AdminAction.OrdersEdit,
+  icon: AdminIcon.Edit,
+  label: 'action_edit',
+  handler(context) {
+    const modalStore = useModalStore();
+    const {parameters} = context;
+
+    modalStore.open(AdminModalKey.ShipmentOptions, {orderIds: parameters.orderIds});
+  },
+});
+
+/**
+ * Shown only in order mode. Exports entire order.
+ */
+export const orderExportAction = defineAction({
+  name: AdminAction.OrdersExport,
+  icon: AdminIcon.Export,
+  label: 'action_export',
+  beforeHandle: resolveOrderParameters,
+  handler: createOrdersMutationHandler(BackendEndpoint.ExportOrders),
+});
+
+/**
+ * Shown if not in order mode. Exports shipments.
+ */
+export const orderExportToShipmentsAction = defineAction({
+  name: AdminAction.OrdersExport,
+  icon: AdminIcon.Export,
+  label: 'action_export_shipments',
+  beforeHandle: resolveOrderParameters,
+  handler: createOrdersMutationHandler(BackendEndpoint.ExportOrders),
+});
+
+/**
+ * Fetch the latest order data from the PDK.
+ */
+export const ordersFetchAction = defineAction({
+  name: AdminAction.OrdersFetch,
+  icon: AdminIcon.Refresh,
+  label: 'action_refresh',
+  handler: createQueryHandler(BackendEndpoint.FetchOrders, (context) => {
+    const orderIds = toArray(context.parameters.orderIds ?? []);
+
+    return orderIds.length === 1 ? String(orderIds[0]) : undefined;
+  }),
+});
+
+/**
+ * Update order data.
+ */
+export const ordersUpdateAction = defineAction({
+  name: AdminAction.OrdersUpdate,
+  icon: AdminIcon.Save,
+  label: 'action_save',
+  beforeHandle: resolveOrderParameters,
+  handler: createOrdersMutationHandler(BackendEndpoint.UpdateOrders),
+});
+
+/**
+ * Shown if not in order mode. Exports order and immediately prints shipment labels.
+ */
+export const ordersExportPrintShipmentsAction = defineAction({
+  name: AdminAction.OrdersExportPrint,
+  icon: AdminIcon.Print,
+  label: 'action_export_print',
+  beforeHandle: resolveOrderParameters,
+  handler: createOrdersMutationHandler(BackendEndpoint.ExportOrders),
+  afterHandle(context) {
+    void executeNextAction(context, ordersPrintAction, context.parameters);
+
+    return context.response;
+  },
+});
+
+/**
+ * Shown if not in order mode. Exports all shipment labels.
+ */
+export const ordersPrintAction = defineAction({
+  name: AdminAction.OrdersPrint,
+  icon: AdminIcon.Print,
+  label: 'action_print',
+  beforeHandle: resolvePrintParameters,
+  handler: createOrdersMutationHandler(BackendEndpoint.PrintOrders, true),
+  async afterHandle(context) {
+    await openOrPrintPdf(context);
+
+    void executeNextAction(context, shipmentsUpdateAction, {
+      ...context.parameters,
+      shipmentIds: getOrderShipmentIds((context.parameters.orderIds as OrderIds) ?? []),
+    });
+
+    return context.response;
+  },
+});
+
+/**
+ * Shown on orders that have been exported to MyParcel using order mode.
+ */
+export const orderViewInBackofficeAction = defineAction({
+  id: 'show-exported-order',
+  icon: AdminIcon.External,
+  label: 'order_view_in_backoffice',
+  handler() {
+    const {platform} = useGlobalContext();
+    const backofficeUrls = {
+      NL: 'https://backoffice.myparcel.nl/orders',
+      BE: 'https://backoffice.sendmyparcel.be/orders',
+    };
+    const url = backofficeUrls[platform.localCountry as 'NL' | 'BE'] || backofficeUrls['NL'];
+    window.open(url, '_blank');
+  },
+});

package/src/actions/definitions/settings.ts

@@ -0,0 +1,11 @@
+import {BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {createMutationHandler} from '../executors';
+import {defineAction} from '../defineAction';
+import {AdminAction, AdminIcon} from '../../data';
+
+export const pluginSettingsUpdateAction = defineAction({
+  name: AdminAction.PluginSettingsUpdate,
+  icon: AdminIcon.Save,
+  label: 'action_save',
+  handler: createMutationHandler(BackendEndpoint.UpdatePluginSettings),
+});

package/src/actions/definitions/shipments.ts

@@ -0,0 +1,61 @@
+import {BackendEndpoint, Variant} from '@myparcel-dev/pdk-common';
+import {openOrPrintPdf, resolvePrintParameters} from '../print';
+import {createShipmentsMutationHandler, executeNextAction} from '../executors';
+import {defineAction} from '../defineAction';
+import {AdminAction, AdminIcon} from '../../data';
+
+export const shipmentsExportReturnAction = defineAction({
+  name: AdminAction.ShipmentsExportReturn,
+  icon: AdminIcon.Return,
+  label: 'action_export_return',
+  handler: createShipmentsMutationHandler(BackendEndpoint.ExportReturn),
+});
+
+/**
+ * Fetch shipments from the MyParcel Api.
+ */
+export const shipmentsUpdateAction = defineAction({
+  name: AdminAction.ShipmentsUpdate,
+  icon: AdminIcon.Refresh,
+  label: 'action_refresh',
+  handler: createShipmentsMutationHandler(BackendEndpoint.UpdateShipments),
+});
+
+/**
+ * Delete shipments.
+ */
+export const shipmentsDeleteAction = defineAction({
+  name: AdminAction.ShipmentsDelete,
+  icon: AdminIcon.Delete,
+  label: 'action_delete',
+  handler: createShipmentsMutationHandler(BackendEndpoint.DeleteShipments),
+  variant: Variant.Error,
+});
+
+/**
+ * Print specific shipments.
+ */
+export const shipmentsPrintAction = defineAction({
+  name: AdminAction.ShipmentsPrint,
+  icon: AdminIcon.Print,
+  label: 'action_print',
+  beforeHandle: resolvePrintParameters,
+  handler: createShipmentsMutationHandler(BackendEndpoint.PrintShipments, true),
+  async afterHandle(context) {
+    await openOrPrintPdf(context);
+
+    void executeNextAction(context, shipmentsUpdateAction, {
+      orderIds: context.parameters?.orderIds as string,
+      shipmentIds: context.parameters?.shipmentIds as number,
+    });
+
+    return context.response;
+  },
+});
+
+export const shipmentActions = [
+  shipmentsPrintAction,
+  shipmentsUpdateAction,
+  shipmentsExportReturnAction,
+  shipmentsDeleteAction,
+];

package/src/actions/definitions/webhooks.ts

@@ -0,0 +1,25 @@
+import {BackendEndpoint, Variant} from '@myparcel-dev/pdk-common';
+import {createMutationHandler, createQueryHandler} from '../executors';
+import {defineAction} from '../defineAction';
+import {AdminAction, AdminIcon} from '../../data';
+
+export const webhooksFetchAction = defineAction({
+  name: AdminAction.WebhooksFetch,
+  label: 'action_fetch_webhooks',
+  handler: createQueryHandler(BackendEndpoint.FetchWebhooks),
+});
+
+export const webhooksCreateAction = defineAction({
+  name: AdminAction.WebhooksCreate,
+  icon: AdminIcon.Add,
+  label: 'action_create',
+  handler: createMutationHandler(BackendEndpoint.CreateWebhooks),
+});
+
+export const webhooksDeleteAction = defineAction({
+  name: AdminAction.WebhooksDelete,
+  icon: AdminIcon.Delete,
+  label: 'action_delete',
+  handler: createMutationHandler(BackendEndpoint.DeleteWebhooks),
+  variant: Variant.Error,
+});

package/src/actions/executors/createHandlerWithParameters.ts

@@ -0,0 +1,29 @@
+import {type BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {type OneOrMore, toArray} from '@myparcel-dev/ts-utils';
+import {type BackendEndpointResponse} from '../../types';
+import {type ActionContext} from './types';
+import {doMutate} from './doMutate';
+
+export const createHandlerWithParameters = async <E extends BackendEndpoint, Bulk extends boolean = false>(
+  args: OneOrMore<number | string>,
+  endpoint: E,
+  context: ActionContext<E>,
+  allowBulk?: Bulk,
+): Promise<OneOrMore<BackendEndpointResponse<E>>> => {
+  const ids = toArray(args);
+
+  if (!ids.length) {
+    throw new Error('No arguments provided');
+  }
+
+  if (allowBulk && ids.length > 1) {
+    // For bulk actions, don't pass ids to the mutations.
+    return doMutate(endpoint, undefined, context);
+  }
+
+  if (ids.length === 1) {
+    return doMutate(endpoint, ids[0], context);
+  }
+
+  return Promise.all(ids.map((id) => doMutate(endpoint, id, context)));
+};

package/src/actions/executors/createMutationHandler.ts

@@ -0,0 +1,10 @@
+import {type BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {type QueryHandler, type QueryModifier} from './types';
+import {doMutate} from './doMutate';
+
+export const createMutationHandler = <E extends BackendEndpoint>(
+  endpoint: E,
+  suffix?: QueryModifier<E>,
+): QueryHandler<E> => {
+  return (context) => doMutate(endpoint, suffix, context);
+};

package/src/actions/executors/createOrdersMutationHandler.ts

@@ -0,0 +1,12 @@
+import {type BackendOrderEndpoint, type OrderIds} from '../../types';
+import {type QueryHandler} from './types';
+import {createHandlerWithParameters} from './createHandlerWithParameters';
+
+export const createOrdersMutationHandler = <E extends BackendOrderEndpoint>(
+  endpoint: E,
+  allowBulk = false,
+): QueryHandler<E> => {
+  return (context) => {
+    return createHandlerWithParameters(context.parameters?.orderIds as OrderIds, endpoint, context, allowBulk);
+  };
+};

package/src/actions/executors/createQueryHandler.ts

@@ -0,0 +1,19 @@
+import {type BackendQueryEndpoints} from '../../types';
+import {useStoreQuery} from '../../composables';
+import {type QueryHandler, type QueryModifier} from './types';
+import {resolveQuerySuffix} from './resolveQuerySuffix';
+
+export const createQueryHandler = <E extends BackendQueryEndpoints>(
+  endpoint: E,
+  suffix?: QueryModifier<E>,
+): QueryHandler<E> => {
+  // @ts-expect-error todo
+  return async (context) => {
+    const resolvedSuffix = resolveQuerySuffix(suffix, context);
+    const query = useStoreQuery(endpoint, resolvedSuffix);
+
+    await query.refetch();
+
+    return query.data;
+  };
+};

package/src/actions/executors/createShipmentsMutationHandler.ts

@@ -0,0 +1,12 @@
+import {type BackendShipmentEndpoint, type ShipmentIds} from '../../types';
+import {type QueryHandler} from './types';
+import {createHandlerWithParameters} from './createHandlerWithParameters';
+
+export const createShipmentsMutationHandler = <E extends BackendShipmentEndpoint>(
+  endpoint: E,
+  allowBulk = false,
+): QueryHandler<E> => {
+  return (context) => {
+    return createHandlerWithParameters(context.parameters?.shipmentIds as ShipmentIds, endpoint, context, allowBulk);
+  };
+};

package/src/actions/executors/doMutate.ts

@@ -0,0 +1,16 @@
+import {type BackendEndpoint} from '@myparcel-dev/pdk-common';
+import {type BackendEndpointResponse} from '../../types';
+import {useStoreQuery} from '../../composables';
+import {type ActionContext, type QueryModifier} from './types';
+import {resolveQuerySuffix} from './resolveQuerySuffix';
+
+export const doMutate = <E extends BackendEndpoint>(
+  endpoint: E,
+  suffix: QueryModifier<E>,
+  context: ActionContext<E>,
+): Promise<BackendEndpointResponse<E>> => {
+  const mutation = useStoreQuery(endpoint, resolveQuerySuffix(suffix, context as unknown as ActionContext<E>));
+
+  // @ts-expect-error todo
+  return mutation.mutateAsync(context.parameters);
+};

package/src/actions/executors/executeAction.ts

@@ -0,0 +1,35 @@
+import {StopActionHandler} from '../stopActionHandler';
+import {type MaybeActionResponse, type MaybeAdminAction} from '../../types';
+import {type ActionContext} from './types';
+import {executeHandler} from './executeHandler';
+import {executeBeforeHandle} from './executeBeforeHandle';
+import {executeAfterHandle} from './executeAfterHandle';
+
+/**
+ * Execute an AdminAction.
+ */
+// eslint-disable-next-line complexity,max-lines-per-function
+export const executeAction = async <A extends MaybeAdminAction>(
+  context: ActionContext<A>,
+): Promise<MaybeActionResponse<A>> => {
+  const {instance} = context;
+  const startTime = Date.now();
+
+  instance.logger.debug('Start', context);
+
+  const resolvedParameters = await executeBeforeHandle(context);
+
+  // If the action was stopped, return early.
+  if (resolvedParameters instanceof StopActionHandler) {
+    instance.logger.debug('Action canceled');
+    return;
+  }
+
+  const response = await executeHandler({...context, parameters: resolvedParameters} as ActionContext<A>);
+
+  const resolvedResponse = await executeAfterHandle(context, response);
+
+  instance.logger.debug('Took', Date.now() - startTime, 'ms');
+
+  return resolvedResponse;
+};

package/src/actions/executors/executeAfterHandle.ts

@@ -0,0 +1,23 @@
+import {type MaybeActionResponse, type MaybeAdminAction} from '../../types';
+import {type ActionContext} from './types';
+
+const AFTER_HANDLE = 'afterHandle';
+
+export async function executeAfterHandle<A extends MaybeAdminAction>(
+  context: ActionContext<A>,
+  response: MaybeActionResponse<A>,
+): Promise<MaybeActionResponse<A>> {
+  const {action, instance} = context;
+
+  try {
+    // @ts-expect-error todo
+    const resolvedResponse = (await action.afterHandle?.({...context, response})) ?? response;
+
+    instance.logger.debug(AFTER_HANDLE, {response, resolvedResponse});
+
+    // @ts-expect-error todo
+    return resolvedResponse;
+  } catch (error) {
+    instance.logger.error(AFTER_HANDLE, error);
+  }
+}