@deenruv/admin-ui 1.0.0

package/esm2022/core/data/providers/customer-data.service.mjs

@@ -0,0 +1,125 @@
+import { LogicalOperator } from '../../common/generated-types';
+import { ADD_CUSTOMERS_TO_GROUP, ADD_NOTE_TO_CUSTOMER, CREATE_CUSTOMER, CREATE_CUSTOMER_ADDRESS, CREATE_CUSTOMER_GROUP, DELETE_CUSTOMER, DELETE_CUSTOMER_ADDRESS, DELETE_CUSTOMER_GROUP, DELETE_CUSTOMER_GROUPS, DELETE_CUSTOMER_NOTE, DELETE_CUSTOMERS, GET_CUSTOMER_GROUP_WITH_CUSTOMERS, GET_CUSTOMER_GROUPS, GET_CUSTOMER_HISTORY, GET_CUSTOMER_LIST, REMOVE_CUSTOMERS_FROM_GROUP, UPDATE_CUSTOMER, UPDATE_CUSTOMER_ADDRESS, UPDATE_CUSTOMER_GROUP, UPDATE_CUSTOMER_NOTE, } from '../definitions/customer-definitions';
+export class CustomerDataService {
+    constructor(baseDataService) {
+        this.baseDataService = baseDataService;
+    }
+    getCustomerList(take = 10, skip = 0, filterTerm) {
+        const filter = filterTerm
+            ? {
+                filter: {
+                    emailAddress: {
+                        contains: filterTerm,
+                    },
+                    lastName: {
+                        contains: filterTerm,
+                    },
+                },
+            }
+            : {};
+        return this.baseDataService.query(GET_CUSTOMER_LIST, {
+            options: {
+                take,
+                skip,
+                ...filter,
+                filterOperator: LogicalOperator.OR,
+            },
+        });
+    }
+    createCustomer(input, password) {
+        return this.baseDataService.mutate(CREATE_CUSTOMER, {
+            input,
+            password,
+        });
+    }
+    updateCustomer(input) {
+        return this.baseDataService.mutate(UPDATE_CUSTOMER, {
+            input,
+        });
+    }
+    deleteCustomer(id) {
+        return this.baseDataService.mutate(DELETE_CUSTOMER, { id });
+    }
+    deleteCustomers(ids) {
+        return this.baseDataService.mutate(DELETE_CUSTOMERS, { ids });
+    }
+    createCustomerAddress(customerId, input) {
+        return this.baseDataService.mutate(CREATE_CUSTOMER_ADDRESS, {
+            customerId,
+            input,
+        });
+    }
+    updateCustomerAddress(input) {
+        return this.baseDataService.mutate(UPDATE_CUSTOMER_ADDRESS, {
+            input,
+        });
+    }
+    deleteCustomerAddress(id) {
+        return this.baseDataService.mutate(DELETE_CUSTOMER_ADDRESS, { id });
+    }
+    createCustomerGroup(input) {
+        return this.baseDataService.mutate(CREATE_CUSTOMER_GROUP, {
+            input,
+        });
+    }
+    updateCustomerGroup(input) {
+        return this.baseDataService.mutate(UPDATE_CUSTOMER_GROUP, {
+            input,
+        });
+    }
+    deleteCustomerGroup(id) {
+        return this.baseDataService.mutate(DELETE_CUSTOMER_GROUP, { id });
+    }
+    deleteCustomerGroups(ids) {
+        return this.baseDataService.mutate(DELETE_CUSTOMER_GROUPS, { ids });
+    }
+    getCustomerGroupList(options) {
+        return this.baseDataService.query(GET_CUSTOMER_GROUPS, {
+            options,
+        });
+    }
+    getCustomerGroupWithCustomers(id, options) {
+        return this.baseDataService.query(GET_CUSTOMER_GROUP_WITH_CUSTOMERS, {
+            id,
+            options,
+        });
+    }
+    addCustomersToGroup(groupId, customerIds) {
+        return this.baseDataService.mutate(ADD_CUSTOMERS_TO_GROUP, {
+            groupId,
+            customerIds,
+        });
+    }
+    removeCustomersFromGroup(groupId, customerIds) {
+        return this.baseDataService.mutate(REMOVE_CUSTOMERS_FROM_GROUP, {
+            groupId,
+            customerIds,
+        });
+    }
+    getCustomerHistory(id, options) {
+        return this.baseDataService.query(GET_CUSTOMER_HISTORY, {
+            id,
+            options,
+        });
+    }
+    addNoteToCustomer(customerId, note) {
+        return this.baseDataService.mutate(ADD_NOTE_TO_CUSTOMER, {
+            input: {
+                note,
+                isPublic: false,
+                id: customerId,
+            },
+        });
+    }
+    updateCustomerNote(input) {
+        return this.baseDataService.mutate(UPDATE_CUSTOMER_NOTE, {
+            input,
+        });
+    }
+    deleteCustomerNote(id) {
+        return this.baseDataService.mutate(DELETE_CUSTOMER_NOTE, {
+            id,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"customer-data.service.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/data/providers/customer-data.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EACH,sBAAsB,EACtB,oBAAoB,EACpB,eAAe,EACf,uBAAuB,EACvB,qBAAqB,EACrB,eAAe,EACf,uBAAuB,EACvB,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,EACpB,gBAAgB,EAChB,iCAAiC,EACjC,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,2BAA2B,EAC3B,eAAe,EACf,uBAAuB,EACvB,qBAAqB,EACrB,oBAAoB,GACvB,MAAM,qCAAqC,CAAC;AAI7C,MAAM,OAAO,mBAAmB;IAC5B,YAAoB,eAAgC;QAAhC,oBAAe,GAAf,eAAe,CAAiB;IAAG,CAAC;IAExD,eAAe,CAAC,IAAI,GAAG,EAAE,EAAE,IAAI,GAAG,CAAC,EAAE,UAAmB;QACpD,MAAM,MAAM,GAAG,UAAU;YACrB,CAAC,CAAC;gBACI,MAAM,EAAE;oBACJ,YAAY,EAAE;wBACV,QAAQ,EAAE,UAAU;qBACvB;oBACD,QAAQ,EAAE;wBACN,QAAQ,EAAE,UAAU;qBACvB;iBACJ;aACJ;YACH,CAAC,CAAC,EAAE,CAAC;QACT,OAAO,IAAI,CAAC,eAAe,CAAC,KAAK,CAG/B,iBAAiB,EAAE;YACjB,OAAO,EAAE;gBACL,IAAI;gBACJ,IAAI;gBACJ,GAAG,MAAM;gBACT,cAAc,EAAE,eAAe,CAAC,EAAE;aACrC;SACJ,CAAC,CAAC;IACP,CAAC;IAED,cAAc,CAAC,KAAkC,EAAE,QAAwB;QACvE,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,eAAe,EAAE;YACf,KAAK;YACL,QAAQ;SACX,CAAC,CAAC;IACP,CAAC;IAED,cAAc,CAAC,KAAkC;QAC7C,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,eAAe,EAAE;YACf,KAAK;SACR,CAAC,CAAC;IACP,CAAC;IAED,cAAc,CAAC,EAAU;QACrB,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,eAAe,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAC/B,CAAC;IAED,eAAe,CAAC,GAAa;QACzB,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,gBAAgB,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;IACjC,CAAC;IAED,qBAAqB,CAAC,UAAkB,EAAE,KAAiC;QACvE,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,uBAAuB,EAAE;YACvB,UAAU;YACV,KAAK;SACR,CAAC,CAAC;IACP,CAAC;IAED,qBAAqB,CAAC,KAAiC;QACnD,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,uBAAuB,EAAE;YACvB,KAAK;SACR,CAAC,CAAC;IACP,CAAC;IAED,qBAAqB,CAAC,EAAU;QAC5B,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,uBAAuB,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IACvC,CAAC;IAED,mBAAmB,CAAC,KAAuC;QACvD,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,qBAAqB,EAAE;YACrB,KAAK;SACR,CAAC,CAAC;IACP,CAAC;IAED,mBAAmB,CAAC,KAAuC;QACvD,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,qBAAqB,EAAE;YACrB,KAAK;SACR,CAAC,CAAC;IACP,CAAC;IAED,mBAAmB,CAAC,EAAU;QAC1B,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,qBAAqB,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IACrC,CAAC;IAED,oBAAoB,CAAC,GAAa;QAC9B,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,sBAAsB,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;IACvC,CAAC;IAED,oBAAoB,CAAC,OAA0C;QAC3D,OAAO,IAAI,CAAC,eAAe,CAAC,KAAK,CAG/B,mBAAmB,EAAE;YACnB,OAAO;SACV,CAAC,CAAC;IACP,CAAC;IAED,6BAA6B,CAAC,EAAU,EAAE,OAAoC;QAC1E,OAAO,IAAI,CAAC,eAAe,CAAC,KAAK,CAG/B,iCAAiC,EAAE;YACjC,EAAE;YACF,OAAO;SACV,CAAC,CAAC;IACP,CAAC;IAED,mBAAmB,CAAC,OAAe,EAAE,WAAqB;QACtD,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,sBAAsB,EAAE;YACtB,OAAO;YACP,WAAW;SACd,CAAC,CAAC;IACP,CAAC;IAED,wBAAwB,CAAC,OAAe,EAAE,WAAqB;QAC3D,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,2BAA2B,EAAE;YAC3B,OAAO;YACP,WAAW;SACd,CAAC,CAAC;IACP,CAAC;IAED,kBAAkB,CAAC,EAAU,EAAE,OAAyC;QACpE,OAAO,IAAI,CAAC,eAAe,CAAC,KAAK,CAG/B,oBAAoB,EAAE;YACpB,EAAE;YACF,OAAO;SACV,CAAC,CAAC;IACP,CAAC;IAED,iBAAiB,CAAC,UAAkB,EAAE,IAAY;QAC9C,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,oBAAoB,EAAE;YACpB,KAAK,EAAE;gBACH,IAAI;gBACJ,QAAQ,EAAE,KAAK;gBACf,EAAE,EAAE,UAAU;aACjB;SACJ,CAAC,CAAC;IACP,CAAC;IAED,kBAAkB,CAAC,KAAsC;QACrD,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,oBAAoB,EAAE;YACpB,KAAK;SACR,CAAC,CAAC;IACP,CAAC;IAED,kBAAkB,CAAC,EAAU;QACzB,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,oBAAoB,EAAE;YACpB,EAAE;SACL,CAAC,CAAC;IACP,CAAC;CACJ","sourcesContent":["import * as Codegen from '../../common/generated-types';\nimport { LogicalOperator } from '../../common/generated-types';\nimport {\n    ADD_CUSTOMERS_TO_GROUP,\n    ADD_NOTE_TO_CUSTOMER,\n    CREATE_CUSTOMER,\n    CREATE_CUSTOMER_ADDRESS,\n    CREATE_CUSTOMER_GROUP,\n    DELETE_CUSTOMER,\n    DELETE_CUSTOMER_ADDRESS,\n    DELETE_CUSTOMER_GROUP,\n    DELETE_CUSTOMER_GROUPS,\n    DELETE_CUSTOMER_NOTE,\n    DELETE_CUSTOMERS,\n    GET_CUSTOMER_GROUP_WITH_CUSTOMERS,\n    GET_CUSTOMER_GROUPS,\n    GET_CUSTOMER_HISTORY,\n    GET_CUSTOMER_LIST,\n    REMOVE_CUSTOMERS_FROM_GROUP,\n    UPDATE_CUSTOMER,\n    UPDATE_CUSTOMER_ADDRESS,\n    UPDATE_CUSTOMER_GROUP,\n    UPDATE_CUSTOMER_NOTE,\n} from '../definitions/customer-definitions';\n\nimport { BaseDataService } from './base-data.service';\n\nexport class CustomerDataService {\n    constructor(private baseDataService: BaseDataService) {}\n\n    getCustomerList(take = 10, skip = 0, filterTerm?: string) {\n        const filter = filterTerm\n            ? {\n                  filter: {\n                      emailAddress: {\n                          contains: filterTerm,\n                      },\n                      lastName: {\n                          contains: filterTerm,\n                      },\n                  },\n              }\n            : {};\n        return this.baseDataService.query<\n            Codegen.GetCustomerListQuery,\n            Codegen.GetCustomerListQueryVariables\n        >(GET_CUSTOMER_LIST, {\n            options: {\n                take,\n                skip,\n                ...filter,\n                filterOperator: LogicalOperator.OR,\n            },\n        });\n    }\n\n    createCustomer(input: Codegen.CreateCustomerInput, password?: string | null) {\n        return this.baseDataService.mutate<\n            Codegen.CreateCustomerMutation,\n            Codegen.CreateCustomerMutationVariables\n        >(CREATE_CUSTOMER, {\n            input,\n            password,\n        });\n    }\n\n    updateCustomer(input: Codegen.UpdateCustomerInput) {\n        return this.baseDataService.mutate<\n            Codegen.UpdateCustomerMutation,\n            Codegen.UpdateCustomerMutationVariables\n        >(UPDATE_CUSTOMER, {\n            input,\n        });\n    }\n\n    deleteCustomer(id: string) {\n        return this.baseDataService.mutate<\n            Codegen.DeleteCustomerMutation,\n            Codegen.DeleteCustomerMutationVariables\n        >(DELETE_CUSTOMER, { id });\n    }\n\n    deleteCustomers(ids: string[]) {\n        return this.baseDataService.mutate<\n            Codegen.DeleteCustomersMutation,\n            Codegen.DeleteCustomersMutationVariables\n        >(DELETE_CUSTOMERS, { ids });\n    }\n\n    createCustomerAddress(customerId: string, input: Codegen.CreateAddressInput) {\n        return this.baseDataService.mutate<\n            Codegen.CreateCustomerAddressMutation,\n            Codegen.CreateCustomerAddressMutationVariables\n        >(CREATE_CUSTOMER_ADDRESS, {\n            customerId,\n            input,\n        });\n    }\n\n    updateCustomerAddress(input: Codegen.UpdateAddressInput) {\n        return this.baseDataService.mutate<\n            Codegen.UpdateCustomerAddressMutation,\n            Codegen.UpdateCustomerAddressMutationVariables\n        >(UPDATE_CUSTOMER_ADDRESS, {\n            input,\n        });\n    }\n\n    deleteCustomerAddress(id: string) {\n        return this.baseDataService.mutate<\n            Codegen.DeleteCustomerAddressMutation,\n            Codegen.DeleteCustomerAddressMutationVariables\n        >(DELETE_CUSTOMER_ADDRESS, { id });\n    }\n\n    createCustomerGroup(input: Codegen.CreateCustomerGroupInput) {\n        return this.baseDataService.mutate<\n            Codegen.CreateCustomerGroupMutation,\n            Codegen.CreateCustomerGroupMutationVariables\n        >(CREATE_CUSTOMER_GROUP, {\n            input,\n        });\n    }\n\n    updateCustomerGroup(input: Codegen.UpdateCustomerGroupInput) {\n        return this.baseDataService.mutate<\n            Codegen.UpdateCustomerGroupMutation,\n            Codegen.UpdateCustomerGroupMutationVariables\n        >(UPDATE_CUSTOMER_GROUP, {\n            input,\n        });\n    }\n\n    deleteCustomerGroup(id: string) {\n        return this.baseDataService.mutate<\n            Codegen.DeleteCustomerGroupMutation,\n            Codegen.DeleteCustomerGroupMutationVariables\n        >(DELETE_CUSTOMER_GROUP, { id });\n    }\n\n    deleteCustomerGroups(ids: string[]) {\n        return this.baseDataService.mutate<\n            Codegen.DeleteCustomerGroupsMutation,\n            Codegen.DeleteCustomerGroupsMutationVariables\n        >(DELETE_CUSTOMER_GROUPS, { ids });\n    }\n\n    getCustomerGroupList(options?: Codegen.CustomerGroupListOptions) {\n        return this.baseDataService.query<\n            Codegen.GetCustomerGroupsQuery,\n            Codegen.GetCustomerGroupsQueryVariables\n        >(GET_CUSTOMER_GROUPS, {\n            options,\n        });\n    }\n\n    getCustomerGroupWithCustomers(id: string, options: Codegen.CustomerListOptions) {\n        return this.baseDataService.query<\n            Codegen.GetCustomerGroupWithCustomersQuery,\n            Codegen.GetCustomerGroupWithCustomersQueryVariables\n        >(GET_CUSTOMER_GROUP_WITH_CUSTOMERS, {\n            id,\n            options,\n        });\n    }\n\n    addCustomersToGroup(groupId: string, customerIds: string[]) {\n        return this.baseDataService.mutate<\n            Codegen.AddCustomersToGroupMutation,\n            Codegen.AddCustomersToGroupMutationVariables\n        >(ADD_CUSTOMERS_TO_GROUP, {\n            groupId,\n            customerIds,\n        });\n    }\n\n    removeCustomersFromGroup(groupId: string, customerIds: string[]) {\n        return this.baseDataService.mutate<\n            Codegen.RemoveCustomersFromGroupMutation,\n            Codegen.RemoveCustomersFromGroupMutationVariables\n        >(REMOVE_CUSTOMERS_FROM_GROUP, {\n            groupId,\n            customerIds,\n        });\n    }\n\n    getCustomerHistory(id: string, options?: Codegen.HistoryEntryListOptions) {\n        return this.baseDataService.query<\n            Codegen.GetCustomerHistoryQuery,\n            Codegen.GetCustomerHistoryQueryVariables\n        >(GET_CUSTOMER_HISTORY, {\n            id,\n            options,\n        });\n    }\n\n    addNoteToCustomer(customerId: string, note: string) {\n        return this.baseDataService.mutate<\n            Codegen.AddNoteToCustomerMutation,\n            Codegen.AddNoteToCustomerMutationVariables\n        >(ADD_NOTE_TO_CUSTOMER, {\n            input: {\n                note,\n                isPublic: false,\n                id: customerId,\n            },\n        });\n    }\n\n    updateCustomerNote(input: Codegen.UpdateCustomerNoteInput) {\n        return this.baseDataService.mutate<\n            Codegen.UpdateCustomerNoteMutation,\n            Codegen.UpdateCustomerNoteMutationVariables\n        >(UPDATE_CUSTOMER_NOTE, {\n            input,\n        });\n    }\n\n    deleteCustomerNote(id: string) {\n        return this.baseDataService.mutate<\n            Codegen.DeleteCustomerNoteMutation,\n            Codegen.DeleteCustomerNoteMutationVariables\n        >(DELETE_CUSTOMER_NOTE, {\n            id,\n        });\n    }\n}\n"]}

package/esm2022/core/data/providers/data.service.mjs

@@ -0,0 +1,90 @@
+import { Injectable } from '@angular/core';
+import { AdministratorDataService } from './administrator-data.service';
+import { AuthDataService } from './auth-data.service';
+import { ClientDataService } from './client-data.service';
+import { CollectionDataService } from './collection-data.service';
+import { CustomerDataService } from './customer-data.service';
+import { FacetDataService } from './facet-data.service';
+import { OrderDataService } from './order-data.service';
+import { ProductDataService } from './product-data.service';
+import { PromotionDataService } from './promotion-data.service';
+import { SettingsDataService } from './settings-data.service';
+import { ShippingMethodDataService } from './shipping-method-data.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./base-data.service";
+/**
+ * @description
+ * Used to interact with the Admin API via GraphQL queries. Internally this service uses the
+ * Apollo Client, which means it maintains a normalized entity cache. For this reason, it is
+ * advisable to always select the `id` field of any entity, which will allow the returned data
+ * to be effectively cached.
+ *
+ * @docsCategory services
+ * @docsPage DataService
+ * @docsWeight 0
+ */
+export class DataService {
+    /** @internal */
+    constructor(baseDataService) {
+        this.baseDataService = baseDataService;
+        this.promotion = new PromotionDataService(baseDataService);
+        this.administrator = new AdministratorDataService(baseDataService);
+        this.auth = new AuthDataService(baseDataService);
+        this.collection = new CollectionDataService(baseDataService);
+        this.product = new ProductDataService(baseDataService);
+        this.client = new ClientDataService(baseDataService);
+        this.facet = new FacetDataService(baseDataService);
+        this.order = new OrderDataService(baseDataService);
+        this.settings = new SettingsDataService(baseDataService);
+        this.customer = new CustomerDataService(baseDataService);
+        this.shippingMethod = new ShippingMethodDataService(baseDataService);
+    }
+    /**
+     * @description
+     * Perform a GraphQL query. Returns a {@link QueryResult} which allows further control over
+     * they type of result returned, e.g. stream of values, single value etc.
+     *
+     * @example
+     * ```ts
+     * const result$ = this.dataService.query(gql`
+     *   query MyQuery($id: ID!) {
+     *     product(id: $id) {
+     *       id
+     *       name
+     *       slug
+     *     }
+     *   },
+     *   { id: 123 },
+     * ).mapSingle(data => data.product);
+     * ```
+     */
+    query(query, variables, fetchPolicy = 'cache-and-network') {
+        return this.baseDataService.query(query, variables, fetchPolicy);
+    }
+    /**
+     * @description
+     * Perform a GraphQL mutation.
+     *
+     * @example
+     * ```ts
+     * const result$ = this.dataService.mutate(gql`
+     *   mutation MyMutation($Codegen.UpdateEntityInput!) {
+     *     updateEntity(input: $input) {
+     *       id
+     *       name
+     *     }
+     *   },
+     *   { Codegen.updateEntityInput },
+     * );
+     * ```
+     */
+    mutate(mutation, variables, update) {
+        return this.baseDataService.mutate(mutation, variables, update);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DataService, deps: [{ token: i1.BaseDataService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DataService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DataService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.BaseDataService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data.service.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/data/providers/data.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAQ3C,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;;;AAG3E;;;;;;;;;;GAUG;AAEH,MAAM,OAAO,WAAW;IAapB,gBAAgB;IAChB,YAAoB,eAAgC;QAAhC,oBAAe,GAAf,eAAe,CAAiB;QAChD,IAAI,CAAC,SAAS,GAAG,IAAI,oBAAoB,CAAC,eAAe,CAAC,CAAC;QAC3D,IAAI,CAAC,aAAa,GAAG,IAAI,wBAAwB,CAAC,eAAe,CAAC,CAAC;QACnE,IAAI,CAAC,IAAI,GAAG,IAAI,eAAe,CAAC,eAAe,CAAC,CAAC;QACjD,IAAI,CAAC,UAAU,GAAG,IAAI,qBAAqB,CAAC,eAAe,CAAC,CAAC;QAC7D,IAAI,CAAC,OAAO,GAAG,IAAI,kBAAkB,CAAC,eAAe,CAAC,CAAC;QACvD,IAAI,CAAC,MAAM,GAAG,IAAI,iBAAiB,CAAC,eAAe,CAAC,CAAC;QACrD,IAAI,CAAC,KAAK,GAAG,IAAI,gBAAgB,CAAC,eAAe,CAAC,CAAC;QACnD,IAAI,CAAC,KAAK,GAAG,IAAI,gBAAgB,CAAC,eAAe,CAAC,CAAC;QACnD,IAAI,CAAC,QAAQ,GAAG,IAAI,mBAAmB,CAAC,eAAe,CAAC,CAAC;QACzD,IAAI,CAAC,QAAQ,GAAG,IAAI,mBAAmB,CAAC,eAAe,CAAC,CAAC;QACzD,IAAI,CAAC,cAAc,GAAG,IAAI,yBAAyB,CAAC,eAAe,CAAC,CAAC;IACzE,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,KAAK,CACD,KAA6C,EAC7C,SAAa,EACb,cAAqC,mBAAmB;QAExD,OAAO,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC;IACrE,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CACF,QAAgD,EAChD,SAAa,EACb,MAAwC;QAExC,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;IACpE,CAAC;+GA9EQ,WAAW;mHAAX,WAAW;;4FAAX,WAAW;kBADvB,UAAU","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ApolloCache, WatchQueryFetchPolicy } from '@apollo/client/core';\nimport { TypedDocumentNode } from '@graphql-typed-document-node/core';\nimport { DocumentNode } from 'graphql';\nimport { Observable } from 'rxjs';\n\nimport { QueryResult } from '../query-result';\n\nimport { AdministratorDataService } from './administrator-data.service';\nimport { AuthDataService } from './auth-data.service';\nimport { BaseDataService } from './base-data.service';\nimport { ClientDataService } from './client-data.service';\nimport { CollectionDataService } from './collection-data.service';\nimport { CustomerDataService } from './customer-data.service';\nimport { FacetDataService } from './facet-data.service';\nimport { OrderDataService } from './order-data.service';\nimport { ProductDataService } from './product-data.service';\nimport { PromotionDataService } from './promotion-data.service';\nimport { SettingsDataService } from './settings-data.service';\nimport { ShippingMethodDataService } from './shipping-method-data.service';\nimport { MutationOptions } from 'apollo-angular/types';\n\n/**\n * @description\n * Used to interact with the Admin API via GraphQL queries. Internally this service uses the\n * Apollo Client, which means it maintains a normalized entity cache. For this reason, it is\n * advisable to always select the `id` field of any entity, which will allow the returned data\n * to be effectively cached.\n *\n * @docsCategory services\n * @docsPage DataService\n * @docsWeight 0\n */\n@Injectable()\nexport class DataService {\n    /** @internal */ promotion: PromotionDataService;\n    /** @internal */ administrator: AdministratorDataService;\n    /** @internal */ auth: AuthDataService;\n    /** @internal */ collection: CollectionDataService;\n    /** @internal */ product: ProductDataService;\n    /** @internal */ client: ClientDataService;\n    /** @internal */ facet: FacetDataService;\n    /** @internal */ order: OrderDataService;\n    /** @internal */ settings: SettingsDataService;\n    /** @internal */ customer: CustomerDataService;\n    /** @internal */ shippingMethod: ShippingMethodDataService;\n\n    /** @internal */\n    constructor(private baseDataService: BaseDataService) {\n        this.promotion = new PromotionDataService(baseDataService);\n        this.administrator = new AdministratorDataService(baseDataService);\n        this.auth = new AuthDataService(baseDataService);\n        this.collection = new CollectionDataService(baseDataService);\n        this.product = new ProductDataService(baseDataService);\n        this.client = new ClientDataService(baseDataService);\n        this.facet = new FacetDataService(baseDataService);\n        this.order = new OrderDataService(baseDataService);\n        this.settings = new SettingsDataService(baseDataService);\n        this.customer = new CustomerDataService(baseDataService);\n        this.shippingMethod = new ShippingMethodDataService(baseDataService);\n    }\n\n    /**\n     * @description\n     * Perform a GraphQL query. Returns a {@link QueryResult} which allows further control over\n     * they type of result returned, e.g. stream of values, single value etc.\n     *\n     * @example\n     * ```ts\n     * const result$ = this.dataService.query(gql`\n     *   query MyQuery($id: ID!) {\n     *     product(id: $id) {\n     *       id\n     *       name\n     *       slug\n     *     }\n     *   },\n     *   { id: 123 },\n     * ).mapSingle(data => data.product);\n     * ```\n     */\n    query<T, V extends Record<string, any> = Record<string, any>>(\n        query: DocumentNode | TypedDocumentNode<T, V>,\n        variables?: V,\n        fetchPolicy: WatchQueryFetchPolicy = 'cache-and-network',\n    ): QueryResult<T, V> {\n        return this.baseDataService.query(query, variables, fetchPolicy);\n    }\n\n    /**\n     * @description\n     * Perform a GraphQL mutation.\n     *\n     * @example\n     * ```ts\n     * const result$ = this.dataService.mutate(gql`\n     *   mutation MyMutation($Codegen.UpdateEntityInput!) {\n     *     updateEntity(input: $input) {\n     *       id\n     *       name\n     *     }\n     *   },\n     *   { Codegen.updateEntityInput },\n     * );\n     * ```\n     */\n    mutate<T, V extends Record<string, any> = Record<string, any>, TCache extends ApolloCache<any> = ApolloCache<T>>(\n        mutation: DocumentNode | TypedDocumentNode<T, V>,\n        variables?: V,\n        update?: MutationOptions<T, V>['update'],\n    ): Observable<T> {\n        return this.baseDataService.mutate(mutation, variables, update);\n    }\n}\n"]}

package/esm2022/core/data/providers/facet-data.service.mjs

@@ -0,0 +1,63 @@
+import { pick } from '@deenruv/common/lib/pick';
+import { ASSIGN_FACETS_TO_CHANNEL, CREATE_FACET, CREATE_FACET_VALUES, DELETE_FACET, DELETE_FACET_VALUES, DELETE_FACETS, GET_FACET_VALUE_LIST, REMOVE_FACETS_FROM_CHANNEL, UPDATE_FACET, UPDATE_FACET_VALUES, } from '../definitions/facet-definitions';
+export class FacetDataService {
+    constructor(baseDataService) {
+        this.baseDataService = baseDataService;
+    }
+    getFacetValues(options, fetchPolicy) {
+        return this.baseDataService.query(GET_FACET_VALUE_LIST, { options }, fetchPolicy);
+    }
+    createFacet(facet) {
+        const input = {
+            input: pick(facet, ['code', 'isPrivate', 'translations', 'values', 'customFields']),
+        };
+        return this.baseDataService.mutate(CREATE_FACET, input);
+    }
+    updateFacet(facet) {
+        const input = {
+            input: pick(facet, ['id', 'code', 'isPrivate', 'translations', 'customFields']),
+        };
+        return this.baseDataService.mutate(UPDATE_FACET, input);
+    }
+    deleteFacet(id, force) {
+        return this.baseDataService.mutate(DELETE_FACET, {
+            id,
+            force,
+        });
+    }
+    deleteFacets(ids, force) {
+        return this.baseDataService.mutate(DELETE_FACETS, {
+            ids,
+            force,
+        });
+    }
+    createFacetValues(facetValues) {
+        const input = {
+            input: facetValues.map(pick(['facetId', 'code', 'translations', 'customFields'])),
+        };
+        return this.baseDataService.mutate(CREATE_FACET_VALUES, input);
+    }
+    updateFacetValues(facetValues) {
+        const input = {
+            input: facetValues.map(pick(['id', 'code', 'translations', 'customFields'])),
+        };
+        return this.baseDataService.mutate(UPDATE_FACET_VALUES, input);
+    }
+    deleteFacetValues(ids, force) {
+        return this.baseDataService.mutate(DELETE_FACET_VALUES, {
+            ids,
+            force,
+        });
+    }
+    assignFacetsToChannel(input) {
+        return this.baseDataService.mutate(ASSIGN_FACETS_TO_CHANNEL, {
+            input,
+        });
+    }
+    removeFacetsFromChannel(input) {
+        return this.baseDataService.mutate(REMOVE_FACETS_FROM_CHANNEL, {
+            input,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"facet-data.service.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/data/providers/facet-data.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAGhD,OAAO,EACH,wBAAwB,EACxB,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,mBAAmB,EACnB,aAAa,EACb,oBAAoB,EACpB,0BAA0B,EAC1B,YAAY,EACZ,mBAAmB,GACtB,MAAM,kCAAkC,CAAC;AAI1C,MAAM,OAAO,gBAAgB;IACzB,YAAoB,eAAgC;QAAhC,oBAAe,GAAf,eAAe,CAAiB;IAAG,CAAC;IAExD,cAAc,CAAC,OAAsC,EAAE,WAAmC;QACtF,OAAO,IAAI,CAAC,eAAe,CAAC,KAAK,CAG/B,oBAAoB,EAAE,EAAE,OAAO,EAAE,EAAE,WAAW,CAAC,CAAC;IACtD,CAAC;IAED,WAAW,CAAC,KAA+B;QACvC,MAAM,KAAK,GAAyC;YAChD,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,cAAc,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC;SACtF,CAAC;QACF,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAC9B,YAAY,EACZ,KAAK,CACR,CAAC;IACN,CAAC;IAED,WAAW,CAAC,KAA+B;QACvC,MAAM,KAAK,GAAyC;YAChD,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,cAAc,EAAE,cAAc,CAAC,CAAC;SAClF,CAAC;QACF,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAC9B,YAAY,EACZ,KAAK,CACR,CAAC;IACN,CAAC;IAED,WAAW,CAAC,EAAU,EAAE,KAAc;QAClC,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAC9B,YAAY,EACZ;YACI,EAAE;YACF,KAAK;SACR,CACJ,CAAC;IACN,CAAC;IAED,YAAY,CAAC,GAAa,EAAE,KAAc;QACtC,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,aAAa,EAAE;YACb,GAAG;YACH,KAAK;SACR,CAAC,CAAC;IACP,CAAC;IAED,iBAAiB,CAAC,WAA4C;QAC1D,MAAM,KAAK,GAA+C;YACtD,KAAK,EAAE,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC;SACpF,CAAC;QACF,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,mBAAmB,EAAE,KAAK,CAAC,CAAC;IAClC,CAAC;IAED,iBAAiB,CAAC,WAA4C;QAC1D,MAAM,KAAK,GAA+C;YACtD,KAAK,EAAE,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC;SAC/E,CAAC;QACF,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,mBAAmB,EAAE,KAAK,CAAC,CAAC;IAClC,CAAC;IAED,iBAAiB,CAAC,GAAa,EAAE,KAAc;QAC3C,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,mBAAmB,EAAE;YACnB,GAAG;YACH,KAAK;SACR,CAAC,CAAC;IACP,CAAC;IAED,qBAAqB,CAAC,KAAyC;QAC3D,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,wBAAwB,EAAE;YACxB,KAAK;SACR,CAAC,CAAC;IACP,CAAC;IAED,uBAAuB,CAAC,KAA2C;QAC/D,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAGhC,0BAA0B,EAAE;YAC1B,KAAK;SACR,CAAC,CAAC;IACP,CAAC;CACJ","sourcesContent":["import { WatchQueryFetchPolicy } from '@apollo/client/core';\nimport { pick } from '@deenruv/common/lib/pick';\n\nimport * as Codegen from '../../common/generated-types';\nimport {\n    ASSIGN_FACETS_TO_CHANNEL,\n    CREATE_FACET,\n    CREATE_FACET_VALUES,\n    DELETE_FACET,\n    DELETE_FACET_VALUES,\n    DELETE_FACETS,\n    GET_FACET_VALUE_LIST,\n    REMOVE_FACETS_FROM_CHANNEL,\n    UPDATE_FACET,\n    UPDATE_FACET_VALUES,\n} from '../definitions/facet-definitions';\n\nimport { BaseDataService } from './base-data.service';\n\nexport class FacetDataService {\n    constructor(private baseDataService: BaseDataService) {}\n\n    getFacetValues(options: Codegen.FacetValueListOptions, fetchPolicy?: WatchQueryFetchPolicy) {\n        return this.baseDataService.query<\n            Codegen.GetFacetValueListQuery,\n            Codegen.GetFacetValueListQueryVariables\n        >(GET_FACET_VALUE_LIST, { options }, fetchPolicy);\n    }\n\n    createFacet(facet: Codegen.CreateFacetInput) {\n        const input: Codegen.CreateFacetMutationVariables = {\n            input: pick(facet, ['code', 'isPrivate', 'translations', 'values', 'customFields']),\n        };\n        return this.baseDataService.mutate<Codegen.CreateFacetMutation, Codegen.CreateFacetMutationVariables>(\n            CREATE_FACET,\n            input,\n        );\n    }\n\n    updateFacet(facet: Codegen.UpdateFacetInput) {\n        const input: Codegen.UpdateFacetMutationVariables = {\n            input: pick(facet, ['id', 'code', 'isPrivate', 'translations', 'customFields']),\n        };\n        return this.baseDataService.mutate<Codegen.UpdateFacetMutation, Codegen.UpdateFacetMutationVariables>(\n            UPDATE_FACET,\n            input,\n        );\n    }\n\n    deleteFacet(id: string, force: boolean) {\n        return this.baseDataService.mutate<Codegen.DeleteFacetMutation, Codegen.DeleteFacetMutationVariables>(\n            DELETE_FACET,\n            {\n                id,\n                force,\n            },\n        );\n    }\n\n    deleteFacets(ids: string[], force: boolean) {\n        return this.baseDataService.mutate<\n            Codegen.DeleteFacetsMutation,\n            Codegen.DeleteFacetsMutationVariables\n        >(DELETE_FACETS, {\n            ids,\n            force,\n        });\n    }\n\n    createFacetValues(facetValues: Codegen.CreateFacetValueInput[]) {\n        const input: Codegen.CreateFacetValuesMutationVariables = {\n            input: facetValues.map(pick(['facetId', 'code', 'translations', 'customFields'])),\n        };\n        return this.baseDataService.mutate<\n            Codegen.CreateFacetValuesMutation,\n            Codegen.CreateFacetValuesMutationVariables\n        >(CREATE_FACET_VALUES, input);\n    }\n\n    updateFacetValues(facetValues: Codegen.UpdateFacetValueInput[]) {\n        const input: Codegen.UpdateFacetValuesMutationVariables = {\n            input: facetValues.map(pick(['id', 'code', 'translations', 'customFields'])),\n        };\n        return this.baseDataService.mutate<\n            Codegen.UpdateFacetValuesMutation,\n            Codegen.UpdateFacetValuesMutationVariables\n        >(UPDATE_FACET_VALUES, input);\n    }\n\n    deleteFacetValues(ids: string[], force: boolean) {\n        return this.baseDataService.mutate<\n            Codegen.DeleteFacetValuesMutation,\n            Codegen.DeleteFacetValuesMutationVariables\n        >(DELETE_FACET_VALUES, {\n            ids,\n            force,\n        });\n    }\n\n    assignFacetsToChannel(input: Codegen.AssignFacetsToChannelInput) {\n        return this.baseDataService.mutate<\n            Codegen.AssignFacetsToChannelMutation,\n            Codegen.AssignFacetsToChannelMutationVariables\n        >(ASSIGN_FACETS_TO_CHANNEL, {\n            input,\n        });\n    }\n\n    removeFacetsFromChannel(input: Codegen.RemoveFacetsFromChannelInput) {\n        return this.baseDataService.mutate<\n            Codegen.RemoveFacetsFromChannelMutation,\n            Codegen.RemoveFacetsFromChannelMutationVariables\n        >(REMOVE_FACETS_FROM_CHANNEL, {\n            input,\n        });\n    }\n}\n"]}

package/esm2022/core/data/providers/fetch-adapter.mjs

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import { lastValueFrom } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * An adapter that allows the Angular HttpClient to be used as a replacement for the global `fetch` function.
+ * This is used to supply a custom fetch function to the apollo-upload-client whilst also allowing the
+ * use of Angular's http infrastructure such as interceptors.
+ */
+export class FetchAdapter {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.fetch = (input, init) => {
+            const url = typeof input === 'string' ? input : input.url;
+            const method = typeof input === 'string' ? (init.method ? init.method : 'GET') : input.method;
+            return lastValueFrom(this.httpClient.request(method, url, {
+                body: init.body,
+                headers: init.headers,
+                observe: 'response',
+                responseType: 'json',
+                withCredentials: true,
+            })).then(result => new Response(JSON.stringify(result.body), {
+                status: result.status,
+                statusText: result.statusText,
+            }));
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FetchAdapter, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FetchAdapter }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FetchAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/data/providers/interceptor.mjs

@@ -0,0 +1,162 @@
+import { HttpErrorResponse, HttpResponse, } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';
+import { DEFAULT_AUTH_TOKEN_HEADER_KEY } from '@deenruv/common/lib/shared-constants';
+import { switchMap, tap } from 'rxjs/operators';
+import { getAppConfig } from '../../app.config';
+import { NotificationService } from '../../providers/notification/notification.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./data.service";
+import * as i2 from "../../providers/auth/auth.service";
+import * as i3 from "@angular/router";
+import * as i4 from "../../providers/local-storage/local-storage.service";
+export const AUTH_REDIRECT_PARAM = 'redirectTo';
+/**
+ * The default interceptor examines all HTTP requests & responses and automatically updates the requesting state
+ * and shows error notifications.
+ */
+export class DefaultInterceptor {
+    constructor(dataService, injector, authService, router, localStorageService) {
+        this.dataService = dataService;
+        this.injector = injector;
+        this.authService = authService;
+        this.router = router;
+        this.localStorageService = localStorageService;
+        this.tokenMethod = 'cookie';
+        this.tokenMethod = getAppConfig().tokenMethod;
+        this.authTokenHeaderKey = getAppConfig().authTokenHeaderKey || DEFAULT_AUTH_TOKEN_HEADER_KEY;
+    }
+    intercept(req, next) {
+        this.dataService.client.startRequest().subscribe();
+        return this.dataService.client.uiState().single$.pipe(switchMap(({ uiState }) => {
+            const request = req.clone({
+                setParams: {
+                    languageCode: uiState?.contentLanguage ?? '',
+                },
+            });
+            return next.handle(request);
+        }), tap(event => {
+            if (event instanceof HttpResponse) {
+                this.checkForAuthToken(event);
+                this.notifyOnError(event);
+                this.dataService.client.completeRequest().subscribe();
+            }
+        }, err => {
+            if (err instanceof HttpErrorResponse) {
+                this.notifyOnError(err);
+                this.dataService.client.completeRequest().subscribe();
+            }
+            else {
+                this.displayErrorNotification(err.message);
+            }
+        }));
+    }
+    notifyOnError(response) {
+        if (response instanceof HttpErrorResponse) {
+            if (response.status === 0) {
+                const { apiHost, apiPort } = getAppConfig();
+                this.displayErrorNotification(_(`error.could-not-connect-to-server`), {
+                    url: `${apiHost}:${apiPort}`,
+                });
+            }
+            else if (response.status === 503 && response.url?.endsWith('/health')) {
+                this.displayErrorNotification(_(`error.health-check-failed`));
+            }
+            else {
+                this.displayErrorNotification(this.extractErrorFromHttpResponse(response));
+            }
+        }
+        else {
+            // GraphQL errors still return 200 OK responses, but have the actual error message
+            // inside the body of the response.
+            const graphQLErrors = response.body.errors;
+            if (graphQLErrors && Array.isArray(graphQLErrors)) {
+                const firstCode = graphQLErrors[0]?.extensions?.code;
+                if (firstCode === 'FORBIDDEN') {
+                    this.authService.logOut().subscribe(() => {
+                        const { loginUrl } = getAppConfig();
+                        // If there is a `loginUrl` which is external to the AdminUI, redirect to it (with no query parameters)
+                        if (loginUrl && !this.areUrlsOnSameOrigin(loginUrl, window.location.origin)) {
+                            window.location.href = loginUrl;
+                            return;
+                        }
+                        // Else, we build the login path from the login url if one is provided or fallback to `/login`
+                        const loginPath = loginUrl ? this.getPathFromLoginUrl(loginUrl) : '/login';
+                        if (!window.location.pathname.includes(loginPath)) {
+                            const path = graphQLErrors[0].path.join(' > ');
+                            this.displayErrorNotification(_(`error.403-forbidden`), { path });
+                        }
+                        // Navigate to the `loginPath` route by ensuring the query param in charge of the redirection is provided
+                        this.router.navigate([loginPath], {
+                            queryParams: {
+                                [AUTH_REDIRECT_PARAM]: btoa(this.router.url),
+                            },
+                        });
+                    });
+                }
+                else if (firstCode === 'CHANNEL_NOT_FOUND') {
+                    const message = graphQLErrors.map(err => err.message).join('\n');
+                    this.displayErrorNotification(message);
+                    this.localStorageService.remove('activeChannelToken');
+                }
+                else {
+                    const message = graphQLErrors.map(err => err.message).join('\n');
+                    this.displayErrorNotification(message);
+                }
+            }
+        }
+    }
+    extractErrorFromHttpResponse(response) {
+        const errors = response.error.errors;
+        if (Array.isArray(errors)) {
+            return errors.map(e => e.message).join('\n');
+        }
+        else {
+            return response.message;
+        }
+    }
+    /**
+     * We need to lazily inject the NotificationService since it depends on the I18nService which
+     * eventually depends on the HttpClient (used to load messages from json files). If we were to
+     * directly inject NotificationService into the constructor, we get a cyclic dependency.
+     */
+    displayErrorNotification(message, vars) {
+        const notificationService = this.injector.get(NotificationService);
+        notificationService.error(message, vars);
+    }
+    /**
+     * If the server is configured to use the "bearer" tokenMethod, each response should be checked
+     * for the existence of an auth token.
+     */
+    checkForAuthToken(response) {
+        if (this.tokenMethod === 'bearer') {
+            const authToken = response.headers.get(this.authTokenHeaderKey);
+            if (authToken) {
+                this.localStorageService.set('authToken', authToken);
+            }
+        }
+    }
+    /**
+     * Determine if two urls are on the same origin.
+     */
+    areUrlsOnSameOrigin(urlA, urlB) {
+        return new URL(urlA).origin === new URL(urlB).origin;
+    }
+    /**
+     * If the provided `loginUrl` is on the same origin than the AdminUI, return the path
+     * after the `/admin`.
+     * Else, return the whole login url.
+     */
+    getPathFromLoginUrl(loginUrl) {
+        if (!this.areUrlsOnSameOrigin(loginUrl, window.location.origin)) {
+            return loginUrl;
+        }
+        return loginUrl.split('/admin')[1];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DefaultInterceptor, deps: [{ token: i1.DataService }, { token: i0.Injector }, { token: i2.AuthService }, { token: i3.Router }, { token: i4.LocalStorageService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DefaultInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DefaultInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.DataService }, { type: i0.Injector }, { type: i2.AuthService }, { type: i3.Router }, { type: i4.LocalStorageService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/data/providers/interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    HttpErrorResponse,\n    HttpEvent,\n    HttpHandler,\n    HttpInterceptor,\n    HttpRequest,\n    HttpResponse,\n} from '@angular/common/http';\nimport { Injectable, Injector } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';\nimport { DEFAULT_AUTH_TOKEN_HEADER_KEY } from '@deenruv/common/lib/shared-constants';\nimport { AdminUiConfig } from '@deenruv/common/lib/shared-types';\nimport { Observable } from 'rxjs';\nimport { switchMap, tap } from 'rxjs/operators';\n\nimport { getAppConfig } from '../../app.config';\nimport { AuthService } from '../../providers/auth/auth.service';\nimport { LocalStorageService } from '../../providers/local-storage/local-storage.service';\nimport { NotificationService } from '../../providers/notification/notification.service';\n\nimport { DataService } from './data.service';\n\nexport const AUTH_REDIRECT_PARAM = 'redirectTo';\n\n/**\n * The default interceptor examines all HTTP requests & responses and automatically updates the requesting state\n * and shows error notifications.\n */\n@Injectable()\nexport class DefaultInterceptor implements HttpInterceptor {\n    private readonly tokenMethod: AdminUiConfig['tokenMethod'] = 'cookie';\n    private readonly authTokenHeaderKey: string;\n\n    constructor(\n        private dataService: DataService,\n        private injector: Injector,\n        private authService: AuthService,\n        private router: Router,\n        private localStorageService: LocalStorageService,\n    ) {\n        this.tokenMethod = getAppConfig().tokenMethod;\n        this.authTokenHeaderKey = getAppConfig().authTokenHeaderKey || DEFAULT_AUTH_TOKEN_HEADER_KEY;\n    }\n\n    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\n        this.dataService.client.startRequest().subscribe();\n        return this.dataService.client.uiState().single$.pipe(\n            switchMap(({ uiState }) => {\n                const request = req.clone({\n                    setParams: {\n                        languageCode: uiState?.contentLanguage ?? '',\n                    },\n                });\n                return next.handle(request);\n            }),\n            tap(\n                event => {\n                    if (event instanceof HttpResponse) {\n                        this.checkForAuthToken(event);\n                        this.notifyOnError(event);\n                        this.dataService.client.completeRequest().subscribe();\n                    }\n                },\n                err => {\n                    if (err instanceof HttpErrorResponse) {\n                        this.notifyOnError(err);\n                        this.dataService.client.completeRequest().subscribe();\n                    } else {\n                        this.displayErrorNotification(err.message);\n                    }\n                },\n            ),\n        );\n    }\n\n    private notifyOnError(response: HttpResponse<any> | HttpErrorResponse) {\n        if (response instanceof HttpErrorResponse) {\n            if (response.status === 0) {\n                const { apiHost, apiPort } = getAppConfig();\n                this.displayErrorNotification(_(`error.could-not-connect-to-server`), {\n                    url: `${apiHost}:${apiPort}`,\n                });\n            } else if (response.status === 503 && response.url?.endsWith('/health')) {\n                this.displayErrorNotification(_(`error.health-check-failed`));\n            } else {\n                this.displayErrorNotification(this.extractErrorFromHttpResponse(response));\n            }\n        } else {\n            // GraphQL errors still return 200 OK responses, but have the actual error message\n            // inside the body of the response.\n            const graphQLErrors = response.body.errors;\n            if (graphQLErrors && Array.isArray(graphQLErrors)) {\n                const firstCode: string = graphQLErrors[0]?.extensions?.code;\n\n                if (firstCode === 'FORBIDDEN') {\n                    this.authService.logOut().subscribe(() => {\n                        const { loginUrl } = getAppConfig();\n                        // If there is a `loginUrl` which is external to the AdminUI, redirect to it (with no query parameters)\n                        if (loginUrl && !this.areUrlsOnSameOrigin(loginUrl, window.location.origin)) {\n                            window.location.href = loginUrl;\n                            return;\n                        }\n\n                        // Else, we build the login path from the login url if one is provided or fallback to `/login`\n                        const loginPath = loginUrl ? this.getPathFromLoginUrl(loginUrl) : '/login';\n\n                        if (!window.location.pathname.includes(loginPath)) {\n                            const path = graphQLErrors[0].path.join(' > ');\n                            this.displayErrorNotification(_(`error.403-forbidden`), { path });\n                        }\n\n                        // Navigate to the `loginPath` route by ensuring the query param in charge of the redirection is provided\n                        this.router.navigate([loginPath], {\n                            queryParams: {\n                                [AUTH_REDIRECT_PARAM]: btoa(this.router.url),\n                            },\n                        });\n                    });\n                } else if (firstCode === 'CHANNEL_NOT_FOUND') {\n                    const message = graphQLErrors.map(err => err.message).join('\\n');\n                    this.displayErrorNotification(message);\n                    this.localStorageService.remove('activeChannelToken');\n                } else {\n                    const message = graphQLErrors.map(err => err.message).join('\\n');\n                    this.displayErrorNotification(message);\n                }\n            }\n        }\n    }\n\n    private extractErrorFromHttpResponse(response: HttpErrorResponse): string {\n        const errors = response.error.errors;\n        if (Array.isArray(errors)) {\n            return errors.map(e => e.message).join('\\n');\n        } else {\n            return response.message;\n        }\n    }\n\n    /**\n     * We need to lazily inject the NotificationService since it depends on the I18nService which\n     * eventually depends on the HttpClient (used to load messages from json files). If we were to\n     * directly inject NotificationService into the constructor, we get a cyclic dependency.\n     */\n    private displayErrorNotification(message: string, vars?: Record<string, any>): void {\n        const notificationService = this.injector.get<NotificationService>(NotificationService);\n        notificationService.error(message, vars);\n    }\n\n    /**\n     * If the server is configured to use the \"bearer\" tokenMethod, each response should be checked\n     * for the existence of an auth token.\n     */\n    private checkForAuthToken(response: HttpResponse<any>) {\n        if (this.tokenMethod === 'bearer') {\n            const authToken = response.headers.get(this.authTokenHeaderKey);\n            if (authToken) {\n                this.localStorageService.set('authToken', authToken);\n            }\n        }\n    }\n\n    /**\n     * Determine if two urls are on the same origin.\n     */\n    private areUrlsOnSameOrigin(urlA: string, urlB: string): boolean {\n        return new URL(urlA).origin === new URL(urlB).origin;\n    }\n\n    /**\n     * If the provided `loginUrl` is on the same origin than the AdminUI, return the path\n     * after the `/admin`.\n     * Else, return the whole login url.\n     */\n    private getPathFromLoginUrl(loginUrl: string): string {\n        if (!this.areUrlsOnSameOrigin(loginUrl, window.location.origin)) {\n            return loginUrl;\n        }\n        return loginUrl.split('/admin')[1];\n    }\n}\n"]}