@vendure/admin-ui 1.4.7 → 2.0.0-next.0

package/esm2020/core/data/providers/collection-data.service.mjs

@@ -0,0 +1,72 @@
+import { pick } from '@vendure/common/lib/pick';
+import { from } from 'rxjs';
+import { bufferCount, concatMap } from 'rxjs/operators';
+import { CREATE_COLLECTION, DELETE_COLLECTION, GET_COLLECTION, GET_COLLECTION_CONTENTS, GET_COLLECTION_FILTERS, GET_COLLECTION_LIST, MOVE_COLLECTION, UPDATE_COLLECTION, } from '../definitions/collection-definitions';
+export class CollectionDataService {
+    constructor(baseDataService) {
+        this.baseDataService = baseDataService;
+    }
+    getCollectionFilters() {
+        return this.baseDataService.query(GET_COLLECTION_FILTERS);
+    }
+    getCollections(take = 10, skip = 0) {
+        return this.baseDataService.query(GET_COLLECTION_LIST, {
+            options: {
+                take,
+                skip,
+            },
+        });
+    }
+    getCollection(id) {
+        return this.baseDataService.query(GET_COLLECTION, {
+            id,
+        });
+    }
+    createCollection(input) {
+        return this.baseDataService.mutate(CREATE_COLLECTION, {
+            input: pick(input, [
+                'translations',
+                'parentId',
+                'assetIds',
+                'featuredAssetId',
+                'filters',
+                'customFields',
+            ]),
+        });
+    }
+    updateCollection(input) {
+        return this.baseDataService.mutate(UPDATE_COLLECTION, {
+            input: pick(input, [
+                'id',
+                'isPrivate',
+                'translations',
+                'assetIds',
+                'featuredAssetId',
+                'filters',
+                'customFields',
+            ]),
+        });
+    }
+    moveCollection(inputs) {
+        return from(inputs).pipe(concatMap(input => this.baseDataService.mutate(MOVE_COLLECTION, { input })), bufferCount(inputs.length));
+    }
+    deleteCollection(id) {
+        return this.baseDataService.mutate(DELETE_COLLECTION, {
+            id,
+        });
+    }
+    getCollectionContents(id, take = 10, skip = 0, filterTerm) {
+        const filter = filterTerm
+            ? { name: { contains: filterTerm } }
+            : undefined;
+        return this.baseDataService.query(GET_COLLECTION_CONTENTS, {
+            id,
+            options: {
+                skip,
+                take,
+                filter,
+            },
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGVjdGlvbi1kYXRhLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL2RhdGEvcHJvdmlkZXJzL2NvbGxlY3Rpb24tZGF0YS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUNoRCxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQzVCLE9BQU8sRUFBRSxXQUFXLEVBQUUsU0FBUyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFHeEQsT0FBTyxFQUNILGlCQUFpQixFQUNqQixpQkFBaUIsRUFDakIsY0FBYyxFQUNkLHVCQUF1QixFQUN2QixzQkFBc0IsRUFDdEIsbUJBQW1CLEVBQ25CLGVBQWUsRUFDZixpQkFBaUIsR0FDcEIsTUFBTSx1Q0FBdUMsQ0FBQztBQUkvQyxNQUFNLE9BQU8scUJBQXFCO0lBQzlCLFlBQW9CLGVBQWdDO1FBQWhDLG9CQUFlLEdBQWYsZUFBZSxDQUFpQjtJQUFHLENBQUM7SUFFeEQsb0JBQW9CO1FBQ2hCLE9BQU8sSUFBSSxDQUFDLGVBQWUsQ0FBQyxLQUFLLENBQW9DLHNCQUFzQixDQUFDLENBQUM7SUFDakcsQ0FBQztJQUVELGNBQWMsQ0FBQyxPQUFlLEVBQUUsRUFBRSxPQUFlLENBQUM7UUFDOUMsT0FBTyxJQUFJLENBQUMsZUFBZSxDQUFDLEtBQUssQ0FHL0IsbUJBQW1CLEVBQUU7WUFDbkIsT0FBTyxFQUFFO2dCQUNMLElBQUk7Z0JBQ0osSUFBSTthQUNQO1NBQ0osQ0FBQyxDQUFDO0lBQ1AsQ0FBQztJQUVELGFBQWEsQ0FBQyxFQUFVO1FBQ3BCLE9BQU8sSUFBSSxDQUFDLGVBQWUsQ0FBQyxLQUFLLENBQzdCLGNBQWMsRUFDZDtZQUNJLEVBQUU7U0FDTCxDQUNKLENBQUM7SUFDTixDQUFDO0lBRUQsZ0JBQWdCLENBQUMsS0FBb0M7UUFDakQsT0FBTyxJQUFJLENBQUMsZUFBZSxDQUFDLE1BQU0sQ0FHaEMsaUJBQWlCLEVBQUU7WUFDakIsS0FBSyxFQUFFLElBQUksQ0FBQyxLQUFLLEVBQUU7Z0JBQ2YsY0FBYztnQkFDZCxVQUFVO2dCQUNWLFVBQVU7Z0JBQ1YsaUJBQWlCO2dCQUNqQixTQUFTO2dCQUNULGNBQWM7YUFDakIsQ0FBQztTQUNMLENBQUMsQ0FBQztJQUNQLENBQUM7SUFFRCxnQkFBZ0IsQ0FBQyxLQUFvQztRQUNqRCxPQUFPLElBQUksQ0FBQyxlQUFlLENBQUMsTUFBTSxDQUdoQyxpQkFBaUIsRUFBRTtZQUNqQixLQUFLLEVBQUUsSUFBSSxDQUFDLEtBQUssRUFBRTtnQkFDZixJQUFJO2dCQUNKLFdBQVc7Z0JBQ1gsY0FBYztnQkFDZCxVQUFVO2dCQUNWLGlCQUFpQjtnQkFDakIsU0FBUztnQkFDVCxjQUFjO2FBQ2pCLENBQUM7U0FDTCxDQUFDLENBQUM7SUFDUCxDQUFDO0lBRUQsY0FBYyxDQUFDLE1BQXFDO1FBQ2hELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FDcEIsU0FBUyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQ2QsSUFBSSxDQUFDLGVBQWUsQ0FBQyxNQUFNLENBR3pCLGVBQWUsRUFBRSxFQUFFLEtBQUssRUFBRSxDQUFDLENBQ2hDLEVBQ0QsV0FBVyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FDN0IsQ0FBQztJQUNOLENBQUM7SUFFRCxnQkFBZ0IsQ0FBQyxFQUFVO1FBQ3ZCLE9BQU8sSUFBSSxDQUFDLGVBQWUsQ0FBQyxNQUFNLENBR2hDLGlCQUFpQixFQUFFO1lBQ2pCLEVBQUU7U0FDTCxDQUFDLENBQUM7SUFDUCxDQUFDO0lBRUQscUJBQXFCLENBQUMsRUFBVSxFQUFFLE9BQWUsRUFBRSxFQUFFLE9BQWUsQ0FBQyxFQUFFLFVBQW1CO1FBQ3RGLE1BQU0sTUFBTSxHQUFHLFVBQVU7WUFDckIsQ0FBQyxDQUFFLEVBQUUsSUFBSSxFQUFFLEVBQUUsUUFBUSxFQUFFLFVBQVUsRUFBRSxFQUF3QztZQUMzRSxDQUFDLENBQUMsU0FBUyxDQUFDO1FBQ2hCLE9BQU8sSUFBSSxDQUFDLGVBQWUsQ0FBQyxLQUFLLENBRy9CLHVCQUF1QixFQUFFO1lBQ3ZCLEVBQUU7WUFDRixPQUFPLEVBQUU7Z0JBQ0wsSUFBSTtnQkFDSixJQUFJO2dCQUNKLE1BQU07YUFDVDtTQUNKLENBQUMsQ0FBQztJQUNQLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHBpY2sgfSBmcm9tICdAdmVuZHVyZS9jb21tb24vbGliL3BpY2snO1xyXG5pbXBvcnQgeyBmcm9tIH0gZnJvbSAncnhqcyc7XHJcbmltcG9ydCB7IGJ1ZmZlckNvdW50LCBjb25jYXRNYXAgfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XHJcblxyXG5pbXBvcnQgKiBhcyBDb2RlZ2VuIGZyb20gJy4uLy4uL2NvbW1vbi9nZW5lcmF0ZWQtdHlwZXMnO1xyXG5pbXBvcnQge1xyXG4gICAgQ1JFQVRFX0NPTExFQ1RJT04sXHJcbiAgICBERUxFVEVfQ09MTEVDVElPTixcclxuICAgIEdFVF9DT0xMRUNUSU9OLFxyXG4gICAgR0VUX0NPTExFQ1RJT05fQ09OVEVOVFMsXHJcbiAgICBHRVRfQ09MTEVDVElPTl9GSUxURVJTLFxyXG4gICAgR0VUX0NPTExFQ1RJT05fTElTVCxcclxuICAgIE1PVkVfQ09MTEVDVElPTixcclxuICAgIFVQREFURV9DT0xMRUNUSU9OLFxyXG59IGZyb20gJy4uL2RlZmluaXRpb25zL2NvbGxlY3Rpb24tZGVmaW5pdGlvbnMnO1xyXG5cclxuaW1wb3J0IHsgQmFzZURhdGFTZXJ2aWNlIH0gZnJvbSAnLi9iYXNlLWRhdGEuc2VydmljZSc7XHJcblxyXG5leHBvcnQgY2xhc3MgQ29sbGVjdGlvbkRhdGFTZXJ2aWNlIHtcclxuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgYmFzZURhdGFTZXJ2aWNlOiBCYXNlRGF0YVNlcnZpY2UpIHt9XHJcblxyXG4gICAgZ2V0Q29sbGVjdGlvbkZpbHRlcnMoKSB7XHJcbiAgICAgICAgcmV0dXJuIHRoaXMuYmFzZURhdGFTZXJ2aWNlLnF1ZXJ5PENvZGVnZW4uR2V0Q29sbGVjdGlvbkZpbHRlcnNRdWVyeT4oR0VUX0NPTExFQ1RJT05fRklMVEVSUyk7XHJcbiAgICB9XHJcblxyXG4gICAgZ2V0Q29sbGVjdGlvbnModGFrZTogbnVtYmVyID0gMTAsIHNraXA6IG51bWJlciA9IDApIHtcclxuICAgICAgICByZXR1cm4gdGhpcy5iYXNlRGF0YVNlcnZpY2UucXVlcnk8XHJcbiAgICAgICAgICAgIENvZGVnZW4uR2V0Q29sbGVjdGlvbkxpc3RRdWVyeSxcclxuICAgICAgICAgICAgQ29kZWdlbi5HZXRDb2xsZWN0aW9uTGlzdFF1ZXJ5VmFyaWFibGVzXHJcbiAgICAgICAgPihHRVRfQ09MTEVDVElPTl9MSVNULCB7XHJcbiAgICAgICAgICAgIG9wdGlvbnM6IHtcclxuICAgICAgICAgICAgICAgIHRha2UsXHJcbiAgICAgICAgICAgICAgICBza2lwLFxyXG4gICAgICAgICAgICB9LFxyXG4gICAgICAgIH0pO1xyXG4gICAgfVxyXG5cclxuICAgIGdldENvbGxlY3Rpb24oaWQ6IHN0cmluZykge1xyXG4gICAgICAgIHJldHVybiB0aGlzLmJhc2VEYXRhU2VydmljZS5xdWVyeTxDb2RlZ2VuLkdldENvbGxlY3Rpb25RdWVyeSwgQ29kZWdlbi5HZXRDb2xsZWN0aW9uUXVlcnlWYXJpYWJsZXM+KFxyXG4gICAgICAgICAgICBHRVRfQ09MTEVDVElPTixcclxuICAgICAgICAgICAge1xyXG4gICAgICAgICAgICAgICAgaWQsXHJcbiAgICAgICAgICAgIH0sXHJcbiAgICAgICAgKTtcclxuICAgIH1cclxuXHJcbiAgICBjcmVhdGVDb2xsZWN0aW9uKGlucHV0OiBDb2RlZ2VuLkNyZWF0ZUNvbGxlY3Rpb25JbnB1dCkge1xyXG4gICAgICAgIHJldHVybiB0aGlzLmJhc2VEYXRhU2VydmljZS5tdXRhdGU8XHJcbiAgICAgICAgICAgIENvZGVnZW4uQ3JlYXRlQ29sbGVjdGlvbk11dGF0aW9uLFxyXG4gICAgICAgICAgICBDb2RlZ2VuLkNyZWF0ZUNvbGxlY3Rpb25NdXRhdGlvblZhcmlhYmxlc1xyXG4gICAgICAgID4oQ1JFQVRFX0NPTExFQ1RJT04sIHtcclxuICAgICAgICAgICAgaW5wdXQ6IHBpY2soaW5wdXQsIFtcclxuICAgICAgICAgICAgICAgICd0cmFuc2xhdGlvbnMnLFxyXG4gICAgICAgICAgICAgICAgJ3BhcmVudElkJyxcclxuICAgICAgICAgICAgICAgICdhc3NldElkcycsXHJcbiAgICAgICAgICAgICAgICAnZmVhdHVyZWRBc3NldElkJyxcclxuICAgICAgICAgICAgICAgICdmaWx0ZXJzJyxcclxuICAgICAgICAgICAgICAgICdjdXN0b21GaWVsZHMnLFxyXG4gICAgICAgICAgICBdKSxcclxuICAgICAgICB9KTtcclxuICAgIH1cclxuXHJcbiAgICB1cGRhdGVDb2xsZWN0aW9uKGlucHV0OiBDb2RlZ2VuLlVwZGF0ZUNvbGxlY3Rpb25JbnB1dCkge1xyXG4gICAgICAgIHJldHVybiB0aGlzLmJhc2VEYXRhU2VydmljZS5tdXRhdGU8XHJcbiAgICAgICAgICAgIENvZGVnZW4uVXBkYXRlQ29sbGVjdGlvbk11dGF0aW9uLFxyXG4gICAgICAgICAgICBDb2RlZ2VuLlVwZGF0ZUNvbGxlY3Rpb25NdXRhdGlvblZhcmlhYmxlc1xyXG4gICAgICAgID4oVVBEQVRFX0NPTExFQ1RJT04sIHtcclxuICAgICAgICAgICAgaW5wdXQ6IHBpY2soaW5wdXQsIFtcclxuICAgICAgICAgICAgICAgICdpZCcsXHJcbiAgICAgICAgICAgICAgICAnaXNQcml2YXRlJyxcclxuICAgICAgICAgICAgICAgICd0cmFuc2xhdGlvbnMnLFxyXG4gICAgICAgICAgICAgICAgJ2Fzc2V0SWRzJyxcclxuICAgICAgICAgICAgICAgICdmZWF0dXJlZEFzc2V0SWQnLFxyXG4gICAgICAgICAgICAgICAgJ2ZpbHRlcnMnLFxyXG4gICAgICAgICAgICAgICAgJ2N1c3RvbUZpZWxkcycsXHJcbiAgICAgICAgICAgIF0pLFxyXG4gICAgICAgIH0pO1xyXG4gICAgfVxyXG5cclxuICAgIG1vdmVDb2xsZWN0aW9uKGlucHV0czogQ29kZWdlbi5Nb3ZlQ29sbGVjdGlvbklucHV0W10pIHtcclxuICAgICAgICByZXR1cm4gZnJvbShpbnB1dHMpLnBpcGUoXHJcbiAgICAgICAgICAgIGNvbmNhdE1hcChpbnB1dCA9PlxyXG4gICAgICAgICAgICAgICAgdGhpcy5iYXNlRGF0YVNlcnZpY2UubXV0YXRlPFxyXG4gICAgICAgICAgICAgICAgICAgIENvZGVnZW4uTW92ZUNvbGxlY3Rpb25NdXRhdGlvbixcclxuICAgICAgICAgICAgICAgICAgICBDb2RlZ2VuLk1vdmVDb2xsZWN0aW9uTXV0YXRpb25WYXJpYWJsZXNcclxuICAgICAgICAgICAgICAgID4oTU9WRV9DT0xMRUNUSU9OLCB7IGlucHV0IH0pLFxyXG4gICAgICAgICAgICApLFxyXG4gICAgICAgICAgICBidWZmZXJDb3VudChpbnB1dHMubGVuZ3RoKSxcclxuICAgICAgICApO1xyXG4gICAgfVxyXG5cclxuICAgIGRlbGV0ZUNvbGxlY3Rpb24oaWQ6IHN0cmluZykge1xyXG4gICAgICAgIHJldHVybiB0aGlzLmJhc2VEYXRhU2VydmljZS5tdXRhdGU8XHJcbiAgICAgICAgICAgIENvZGVnZW4uRGVsZXRlQ29sbGVjdGlvbk11dGF0aW9uLFxyXG4gICAgICAgICAgICBDb2RlZ2VuLkRlbGV0ZUNvbGxlY3Rpb25NdXRhdGlvblZhcmlhYmxlc1xyXG4gICAgICAgID4oREVMRVRFX0NPTExFQ1RJT04sIHtcclxuICAgICAgICAgICAgaWQsXHJcbiAgICAgICAgfSk7XHJcbiAgICB9XHJcblxyXG4gICAgZ2V0Q29sbGVjdGlvbkNvbnRlbnRzKGlkOiBzdHJpbmcsIHRha2U6IG51bWJlciA9IDEwLCBza2lwOiBudW1iZXIgPSAwLCBmaWx0ZXJUZXJtPzogc3RyaW5nKSB7XHJcbiAgICAgICAgY29uc3QgZmlsdGVyID0gZmlsdGVyVGVybVxyXG4gICAgICAgICAgICA/ICh7IG5hbWU6IHsgY29udGFpbnM6IGZpbHRlclRlcm0gfSB9IGFzIENvZGVnZW4uQ29sbGVjdGlvbkZpbHRlclBhcmFtZXRlcilcclxuICAgICAgICAgICAgOiB1bmRlZmluZWQ7XHJcbiAgICAgICAgcmV0dXJuIHRoaXMuYmFzZURhdGFTZXJ2aWNlLnF1ZXJ5PFxyXG4gICAgICAgICAgICBDb2RlZ2VuLkdldENvbGxlY3Rpb25Db250ZW50c1F1ZXJ5LFxyXG4gICAgICAgICAgICBDb2RlZ2VuLkdldENvbGxlY3Rpb25Db250ZW50c1F1ZXJ5VmFyaWFibGVzXHJcbiAgICAgICAgPihHRVRfQ09MTEVDVElPTl9DT05URU5UUywge1xyXG4gICAgICAgICAgICBpZCxcclxuICAgICAgICAgICAgb3B0aW9uczoge1xyXG4gICAgICAgICAgICAgICAgc2tpcCxcclxuICAgICAgICAgICAgICAgIHRha2UsXHJcbiAgICAgICAgICAgICAgICBmaWx0ZXIsXHJcbiAgICAgICAgICAgIH0sXHJcbiAgICAgICAgfSk7XHJcbiAgICB9XHJcbn1cclxuIl19

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

@@ -0,0 +1,120 @@
+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_NOTE, GET_CUSTOMER, GET_CUSTOMER_GROUPS, GET_CUSTOMER_GROUP_WITH_CUSTOMERS, 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,
+                    },
+                },
+            }
+            : {};
+        return this.baseDataService.query(GET_CUSTOMER_LIST, {
+            options: {
+                take,
+                skip,
+                ...filter,
+            },
+        });
+    }
+    getCustomer(id, orderListOptions) {
+        return this.baseDataService.query(GET_CUSTOMER, {
+            id,
+            orderListOptions,
+        });
+    }
+    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 });
+    }
+    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 });
+    }
+    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,EACH,sBAAsB,EACtB,oBAAoB,EACpB,eAAe,EACf,uBAAuB,EACvB,qBAAqB,EACrB,eAAe,EACf,uBAAuB,EACvB,qBAAqB,EACrB,oBAAoB,EACpB,YAAY,EACZ,mBAAmB,EACnB,iCAAiC,EACjC,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,OAAe,EAAE,EAAE,OAAe,CAAC,EAAE,UAAmB;QACpE,MAAM,MAAM,GAAG,UAAU;YACrB,CAAC,CAAC;gBACI,MAAM,EAAE;oBACJ,YAAY,EAAE;wBACV,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;aACZ;SACJ,CAAC,CAAC;IACP,CAAC;IAED,WAAW,CAAC,EAAU,EAAE,gBAA2C;QAC/D,OAAO,IAAI,CAAC,eAAe,CAAC,KAAK,CAC7B,YAAY,EACZ;YACI,EAAE;YACF,gBAAgB;SACnB,CACJ,CAAC;IACN,CAAC;IAED,cAAc,CAAC,KAAkC,EAAE,QAAiB;QAChE,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,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,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';\r\nimport {\r\n    ADD_CUSTOMERS_TO_GROUP,\r\n    ADD_NOTE_TO_CUSTOMER,\r\n    CREATE_CUSTOMER,\r\n    CREATE_CUSTOMER_ADDRESS,\r\n    CREATE_CUSTOMER_GROUP,\r\n    DELETE_CUSTOMER,\r\n    DELETE_CUSTOMER_ADDRESS,\r\n    DELETE_CUSTOMER_GROUP,\r\n    DELETE_CUSTOMER_NOTE,\r\n    GET_CUSTOMER,\r\n    GET_CUSTOMER_GROUPS,\r\n    GET_CUSTOMER_GROUP_WITH_CUSTOMERS,\r\n    GET_CUSTOMER_HISTORY,\r\n    GET_CUSTOMER_LIST,\r\n    REMOVE_CUSTOMERS_FROM_GROUP,\r\n    UPDATE_CUSTOMER,\r\n    UPDATE_CUSTOMER_ADDRESS,\r\n    UPDATE_CUSTOMER_GROUP,\r\n    UPDATE_CUSTOMER_NOTE,\r\n} from '../definitions/customer-definitions';\r\n\r\nimport { BaseDataService } from './base-data.service';\r\n\r\nexport class CustomerDataService {\r\n    constructor(private baseDataService: BaseDataService) {}\r\n\r\n    getCustomerList(take: number = 10, skip: number = 0, filterTerm?: string) {\r\n        const filter = filterTerm\r\n            ? {\r\n                  filter: {\r\n                      emailAddress: {\r\n                          contains: filterTerm,\r\n                      },\r\n                  },\r\n              }\r\n            : {};\r\n        return this.baseDataService.query<\r\n            Codegen.GetCustomerListQuery,\r\n            Codegen.GetCustomerListQueryVariables\r\n        >(GET_CUSTOMER_LIST, {\r\n            options: {\r\n                take,\r\n                skip,\r\n                ...filter,\r\n            },\r\n        });\r\n    }\r\n\r\n    getCustomer(id: string, orderListOptions?: Codegen.OrderListOptions) {\r\n        return this.baseDataService.query<Codegen.GetCustomerQuery, Codegen.GetCustomerQueryVariables>(\r\n            GET_CUSTOMER,\r\n            {\r\n                id,\r\n                orderListOptions,\r\n            },\r\n        );\r\n    }\r\n\r\n    createCustomer(input: Codegen.CreateCustomerInput, password?: string) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.CreateCustomerMutation,\r\n            Codegen.CreateCustomerMutationVariables\r\n        >(CREATE_CUSTOMER, {\r\n            input,\r\n            password,\r\n        });\r\n    }\r\n\r\n    updateCustomer(input: Codegen.UpdateCustomerInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.UpdateCustomerMutation,\r\n            Codegen.UpdateCustomerMutationVariables\r\n        >(UPDATE_CUSTOMER, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    deleteCustomer(id: string) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.DeleteCustomerMutation,\r\n            Codegen.DeleteCustomerMutationVariables\r\n        >(DELETE_CUSTOMER, { id });\r\n    }\r\n\r\n    createCustomerAddress(customerId: string, input: Codegen.CreateAddressInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.CreateCustomerAddressMutation,\r\n            Codegen.CreateCustomerAddressMutationVariables\r\n        >(CREATE_CUSTOMER_ADDRESS, {\r\n            customerId,\r\n            input,\r\n        });\r\n    }\r\n\r\n    updateCustomerAddress(input: Codegen.UpdateAddressInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.UpdateCustomerAddressMutation,\r\n            Codegen.UpdateCustomerAddressMutationVariables\r\n        >(UPDATE_CUSTOMER_ADDRESS, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    deleteCustomerAddress(id: string) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.DeleteCustomerAddressMutation,\r\n            Codegen.DeleteCustomerAddressMutationVariables\r\n        >(DELETE_CUSTOMER_ADDRESS, { id });\r\n    }\r\n\r\n    createCustomerGroup(input: Codegen.CreateCustomerGroupInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.CreateCustomerGroupMutation,\r\n            Codegen.CreateCustomerGroupMutationVariables\r\n        >(CREATE_CUSTOMER_GROUP, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    updateCustomerGroup(input: Codegen.UpdateCustomerGroupInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.UpdateCustomerGroupMutation,\r\n            Codegen.UpdateCustomerGroupMutationVariables\r\n        >(UPDATE_CUSTOMER_GROUP, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    deleteCustomerGroup(id: string) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.DeleteCustomerGroupMutation,\r\n            Codegen.DeleteCustomerGroupMutationVariables\r\n        >(DELETE_CUSTOMER_GROUP, { id });\r\n    }\r\n\r\n    getCustomerGroupList(options?: Codegen.CustomerGroupListOptions) {\r\n        return this.baseDataService.query<\r\n            Codegen.GetCustomerGroupsQuery,\r\n            Codegen.GetCustomerGroupsQueryVariables\r\n        >(GET_CUSTOMER_GROUPS, {\r\n            options,\r\n        });\r\n    }\r\n\r\n    getCustomerGroupWithCustomers(id: string, options: Codegen.CustomerListOptions) {\r\n        return this.baseDataService.query<\r\n            Codegen.GetCustomerGroupWithCustomersQuery,\r\n            Codegen.GetCustomerGroupWithCustomersQueryVariables\r\n        >(GET_CUSTOMER_GROUP_WITH_CUSTOMERS, {\r\n            id,\r\n            options,\r\n        });\r\n    }\r\n\r\n    addCustomersToGroup(groupId: string, customerIds: string[]) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.AddCustomersToGroupMutation,\r\n            Codegen.AddCustomersToGroupMutationVariables\r\n        >(ADD_CUSTOMERS_TO_GROUP, {\r\n            groupId,\r\n            customerIds,\r\n        });\r\n    }\r\n\r\n    removeCustomersFromGroup(groupId: string, customerIds: string[]) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.RemoveCustomersFromGroupMutation,\r\n            Codegen.RemoveCustomersFromGroupMutationVariables\r\n        >(REMOVE_CUSTOMERS_FROM_GROUP, {\r\n            groupId,\r\n            customerIds,\r\n        });\r\n    }\r\n\r\n    getCustomerHistory(id: string, options?: Codegen.HistoryEntryListOptions) {\r\n        return this.baseDataService.query<\r\n            Codegen.GetCustomerHistoryQuery,\r\n            Codegen.GetCustomerHistoryQueryVariables\r\n        >(GET_CUSTOMER_HISTORY, {\r\n            id,\r\n            options,\r\n        });\r\n    }\r\n\r\n    addNoteToCustomer(customerId: string, note: string) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.AddNoteToCustomerMutation,\r\n            Codegen.AddNoteToCustomerMutationVariables\r\n        >(ADD_NOTE_TO_CUSTOMER, {\r\n            input: {\r\n                note,\r\n                isPublic: false,\r\n                id: customerId,\r\n            },\r\n        });\r\n    }\r\n\r\n    updateCustomerNote(input: Codegen.UpdateCustomerNoteInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.UpdateCustomerNoteMutation,\r\n            Codegen.UpdateCustomerNoteMutationVariables\r\n        >(UPDATE_CUSTOMER_NOTE, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    deleteCustomerNote(id: string) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.DeleteCustomerNoteMutation,\r\n            Codegen.DeleteCustomerNoteMutationVariables\r\n        >(DELETE_CUSTOMER_NOTE, {\r\n            id,\r\n        });\r\n    }\r\n}\r\n"]}

package/esm2020/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 providers
+ * @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
+     * ```TypeScript
+     * 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
+     * ```TypeScript
+     * 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);
+    }
+}
+DataService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DataService, deps: [{ token: i1.BaseDataService }], target: i0.ɵɵFactoryTarget.Injectable });
+DataService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DataService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DataService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ 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;AAO3C,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;;;AAE3E;;;;;;;;;;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,KAAmB,EACnB,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,QAAsB,EACtB,SAAa,EACb,MAA6B;QAE7B,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;IACpE,CAAC;;wGA9EQ,WAAW;4GAAX,WAAW;2FAAX,WAAW;kBADvB,UAAU","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { MutationUpdaterFn, WatchQueryFetchPolicy } from '@apollo/client/core';\r\nimport { DocumentNode } from 'graphql';\r\nimport { Observable } from 'rxjs';\r\n\r\nimport { QueryResult } from '../query-result';\r\n\r\nimport { AdministratorDataService } from './administrator-data.service';\r\nimport { AuthDataService } from './auth-data.service';\r\nimport { BaseDataService } from './base-data.service';\r\nimport { ClientDataService } from './client-data.service';\r\nimport { CollectionDataService } from './collection-data.service';\r\nimport { CustomerDataService } from './customer-data.service';\r\nimport { FacetDataService } from './facet-data.service';\r\nimport { OrderDataService } from './order-data.service';\r\nimport { ProductDataService } from './product-data.service';\r\nimport { PromotionDataService } from './promotion-data.service';\r\nimport { SettingsDataService } from './settings-data.service';\r\nimport { ShippingMethodDataService } from './shipping-method-data.service';\r\n\r\n/**\r\n * @description\r\n * Used to interact with the Admin API via GraphQL queries. Internally this service uses the\r\n * Apollo Client, which means it maintains a normalized entity cache. For this reason, it is\r\n * advisable to always select the `id` field of any entity, which will allow the returned data\r\n * to be effectively cached.\r\n *\r\n * @docsCategory providers\r\n * @docsPage DataService\r\n * @docsWeight 0\r\n */\r\n@Injectable()\r\nexport class DataService {\r\n    /** @internal */ promotion: PromotionDataService;\r\n    /** @internal */ administrator: AdministratorDataService;\r\n    /** @internal */ auth: AuthDataService;\r\n    /** @internal */ collection: CollectionDataService;\r\n    /** @internal */ product: ProductDataService;\r\n    /** @internal */ client: ClientDataService;\r\n    /** @internal */ facet: FacetDataService;\r\n    /** @internal */ order: OrderDataService;\r\n    /** @internal */ settings: SettingsDataService;\r\n    /** @internal */ customer: CustomerDataService;\r\n    /** @internal */ shippingMethod: ShippingMethodDataService;\r\n\r\n    /** @internal */\r\n    constructor(private baseDataService: BaseDataService) {\r\n        this.promotion = new PromotionDataService(baseDataService);\r\n        this.administrator = new AdministratorDataService(baseDataService);\r\n        this.auth = new AuthDataService(baseDataService);\r\n        this.collection = new CollectionDataService(baseDataService);\r\n        this.product = new ProductDataService(baseDataService);\r\n        this.client = new ClientDataService(baseDataService);\r\n        this.facet = new FacetDataService(baseDataService);\r\n        this.order = new OrderDataService(baseDataService);\r\n        this.settings = new SettingsDataService(baseDataService);\r\n        this.customer = new CustomerDataService(baseDataService);\r\n        this.shippingMethod = new ShippingMethodDataService(baseDataService);\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Perform a GraphQL query. Returns a {@link QueryResult} which allows further control over\r\n     * they type of result returned, e.g. stream of values, single value etc.\r\n     *\r\n     * @example\r\n     * ```TypeScript\r\n     * const result$ = this.dataService.query(gql`\r\n     *   query MyQuery($id: ID!) {\r\n     *     product(id: $id) {\r\n     *       id\r\n     *       name\r\n     *       slug\r\n     *     }\r\n     *   },\r\n     *   { id: 123 },\r\n     * ).mapSingle(data => data.product);\r\n     * ```\r\n     */\r\n    query<T, V = Record<string, any>>(\r\n        query: DocumentNode,\r\n        variables?: V,\r\n        fetchPolicy: WatchQueryFetchPolicy = 'cache-and-network',\r\n    ): QueryResult<T, V> {\r\n        return this.baseDataService.query(query, variables, fetchPolicy);\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Perform a GraphQL mutation.\r\n     *\r\n     * @example\r\n     * ```TypeScript\r\n     * const result$ = this.dataService.mutate(gql`\r\n     *   mutation MyMutation($Codegen.UpdateEntityInput!) {\r\n     *     updateEntity(input: $input) {\r\n     *       id\r\n     *       name\r\n     *     }\r\n     *   },\r\n     *   { Codegen.updateEntityInput },\r\n     * );\r\n     * ```\r\n     */\r\n    mutate<T, V = Record<string, any>>(\r\n        mutation: DocumentNode,\r\n        variables?: V,\r\n        update?: MutationUpdaterFn<T>,\r\n    ): Observable<T> {\r\n        return this.baseDataService.mutate(mutation, variables, update);\r\n    }\r\n}\r\n"]}

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

@@ -0,0 +1,60 @@
+import { pick } from '@vendure/common/lib/pick';
+import { CREATE_FACET, CREATE_FACET_VALUES, DELETE_FACET, DELETE_FACET_VALUES, GET_FACET_LIST, GET_FACET_WITH_VALUES, UPDATE_FACET, UPDATE_FACET_VALUES, } from '../definitions/facet-definitions';
+export class FacetDataService {
+    constructor(baseDataService) {
+        this.baseDataService = baseDataService;
+    }
+    getFacets(take = 10, skip = 0) {
+        return this.baseDataService.query(GET_FACET_LIST, {
+            options: {
+                take,
+                skip,
+            },
+        });
+    }
+    getAllFacets() {
+        return this.baseDataService.query(GET_FACET_LIST, {});
+    }
+    getFacet(id) {
+        return this.baseDataService.query(GET_FACET_WITH_VALUES, {
+            id,
+        });
+    }
+    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,
+        });
+    }
+    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,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,36 @@
+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 => {
+                return new Response(JSON.stringify(result.body), {
+                    status: result.status,
+                    statusText: result.statusText,
+                });
+            });
+        };
+    }
+}
+FetchAdapter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: FetchAdapter, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+FetchAdapter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: FetchAdapter });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: FetchAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,136 @@
+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 '@vendure/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 "../providers/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 graqhQLErrors = response.body.errors;
+            if (graqhQLErrors && Array.isArray(graqhQLErrors)) {
+                const firstCode = graqhQLErrors[0]?.extensions?.code;
+                if (firstCode === 'FORBIDDEN') {
+                    this.authService.logOut().subscribe(() => {
+                        if (!window.location.pathname.includes('login')) {
+                            const path = graqhQLErrors[0].path.join(' > ');
+                            this.displayErrorNotification(_(`error.403-forbidden`), { path });
+                        }
+                        this.router.navigate(['/login'], {
+                            queryParams: {
+                                [AUTH_REDIRECT_PARAM]: btoa(this.router.url),
+                            },
+                        });
+                    });
+                }
+                else if (firstCode === 'CHANNEL_NOT_FOUND') {
+                    const message = graqhQLErrors.map(err => err.message).join('\n');
+                    this.displayErrorNotification(message);
+                    this.localStorageService.remove('activeChannelToken');
+                }
+                else {
+                    const message = graqhQLErrors.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);
+            }
+        }
+    }
+}
+DefaultInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DefaultInterceptor, deps: [{ token: i1.DataService }, { token: i0.Injector }, { token: i2.AuthService }, { token: i3.Router }, { token: i4.LocalStorageService }], target: i0.ɵɵFactoryTarget.Injectable });
+DefaultInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DefaultInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DefaultInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ 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 '@vendure/common/lib/shared-constants';\nimport { AdminUiConfig } from '@vendure/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';\nimport { DataService } from '../providers/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 graqhQLErrors = response.body.errors;\n            if (graqhQLErrors && Array.isArray(graqhQLErrors)) {\n                const firstCode: string = graqhQLErrors[0]?.extensions?.code;\n                if (firstCode === 'FORBIDDEN') {\n                    this.authService.logOut().subscribe(() => {\n                        if (!window.location.pathname.includes('login')) {\n                            const path = graqhQLErrors[0].path.join(' > ');\n                            this.displayErrorNotification(_(`error.403-forbidden`), { path });\n                        }\n                        this.router.navigate(['/login'], {\n                            queryParams: {\n                                [AUTH_REDIRECT_PARAM]: btoa(this.router.url),\n                            },\n                        });\n                    });\n                } else if (firstCode === 'CHANNEL_NOT_FOUND') {\n                    const message = graqhQLErrors.map(err => err.message).join('\\n');\n                    this.displayErrorNotification(message);\n                    this.localStorageService.remove('activeChannelToken');\n                } else {\n                    const message = graqhQLErrors.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"]}