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

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

@@ -0,0 +1,235 @@
+import { pick } from '@vendure/common/lib/pick';
+import { JobState } from '../../common/generated-types';
+import { ADD_MEMBERS_TO_ZONE, CANCEL_JOB, CREATE_CHANNEL, CREATE_COUNTRY, CREATE_PAYMENT_METHOD, CREATE_TAX_CATEGORY, CREATE_TAX_RATE, CREATE_ZONE, DELETE_CHANNEL, DELETE_COUNTRY, DELETE_PAYMENT_METHOD, DELETE_TAX_CATEGORY, DELETE_TAX_RATE, DELETE_ZONE, GET_ACTIVE_CHANNEL, GET_AVAILABLE_COUNTRIES, GET_CHANNEL, GET_CHANNELS, GET_COUNTRY, GET_COUNTRY_LIST, GET_GLOBAL_SETTINGS, GET_JOBS_BY_ID, GET_JOBS_LIST, GET_JOB_INFO, GET_JOB_QUEUE_LIST, GET_PAYMENT_METHOD, GET_PAYMENT_METHOD_LIST, GET_PAYMENT_METHOD_OPERATIONS, GET_TAX_CATEGORIES, GET_TAX_CATEGORY, GET_TAX_RATE, GET_TAX_RATE_LIST, GET_TAX_RATE_LIST_SIMPLE, GET_ZONES, REMOVE_MEMBERS_FROM_ZONE, UPDATE_CHANNEL, UPDATE_COUNTRY, UPDATE_GLOBAL_SETTINGS, UPDATE_PAYMENT_METHOD, UPDATE_TAX_CATEGORY, UPDATE_TAX_RATE, UPDATE_ZONE, } from '../definitions/settings-definitions';
+export class SettingsDataService {
+    constructor(baseDataService) {
+        this.baseDataService = baseDataService;
+    }
+    getCountries(take = 10, skip = 0, filterTerm) {
+        return this.baseDataService.query(GET_COUNTRY_LIST, {
+            options: {
+                take,
+                skip,
+                filter: {
+                    name: filterTerm ? { contains: filterTerm } : null,
+                },
+            },
+        });
+    }
+    getAvailableCountries() {
+        return this.baseDataService.query(GET_AVAILABLE_COUNTRIES);
+    }
+    getCountry(id) {
+        return this.baseDataService.query(GET_COUNTRY, { id });
+    }
+    createCountry(input) {
+        return this.baseDataService.mutate(CREATE_COUNTRY, {
+            input: pick(input, ['code', 'enabled', 'translations', 'customFields']),
+        });
+    }
+    updateCountry(input) {
+        return this.baseDataService.mutate(UPDATE_COUNTRY, {
+            input: pick(input, ['id', 'code', 'enabled', 'translations', 'customFields']),
+        });
+    }
+    deleteCountry(id) {
+        return this.baseDataService.mutate(DELETE_COUNTRY, {
+            id,
+        });
+    }
+    getZones() {
+        return this.baseDataService.query(GET_ZONES);
+    }
+    getZone(id) {
+        return this.baseDataService.query(GET_ZONES, {
+            id,
+        });
+    }
+    createZone(input) {
+        return this.baseDataService.mutate(CREATE_ZONE, {
+            input,
+        });
+    }
+    updateZone(input) {
+        return this.baseDataService.mutate(UPDATE_ZONE, {
+            input,
+        });
+    }
+    deleteZone(id) {
+        return this.baseDataService.mutate(DELETE_ZONE, {
+            id,
+        });
+    }
+    addMembersToZone(zoneId, memberIds) {
+        return this.baseDataService.mutate(ADD_MEMBERS_TO_ZONE, {
+            zoneId,
+            memberIds,
+        });
+    }
+    removeMembersFromZone(zoneId, memberIds) {
+        return this.baseDataService.mutate(REMOVE_MEMBERS_FROM_ZONE, {
+            zoneId,
+            memberIds,
+        });
+    }
+    getTaxCategories() {
+        return this.baseDataService.query(GET_TAX_CATEGORIES);
+    }
+    getTaxCategory(id) {
+        return this.baseDataService.query(GET_TAX_CATEGORY, {
+            id,
+        });
+    }
+    createTaxCategory(input) {
+        return this.baseDataService.mutate(CREATE_TAX_CATEGORY, {
+            input,
+        });
+    }
+    updateTaxCategory(input) {
+        return this.baseDataService.mutate(UPDATE_TAX_CATEGORY, {
+            input,
+        });
+    }
+    deleteTaxCategory(id) {
+        return this.baseDataService.mutate(DELETE_TAX_CATEGORY, {
+            id,
+        });
+    }
+    getTaxRates(take = 10, skip = 0, fetchPolicy) {
+        return this.baseDataService.query(GET_TAX_RATE_LIST, {
+            options: {
+                take,
+                skip,
+            },
+        }, fetchPolicy);
+    }
+    getTaxRatesSimple(take = 10, skip = 0, fetchPolicy) {
+        return this.baseDataService.query(GET_TAX_RATE_LIST_SIMPLE, {
+            options: {
+                take,
+                skip,
+            },
+        }, fetchPolicy);
+    }
+    getTaxRate(id) {
+        return this.baseDataService.query(GET_TAX_RATE, {
+            id,
+        });
+    }
+    createTaxRate(input) {
+        return this.baseDataService.mutate(CREATE_TAX_RATE, {
+            input,
+        });
+    }
+    updateTaxRate(input) {
+        return this.baseDataService.mutate(UPDATE_TAX_RATE, {
+            input,
+        });
+    }
+    deleteTaxRate(id) {
+        return this.baseDataService.mutate(DELETE_TAX_RATE, {
+            id,
+        });
+    }
+    getChannels() {
+        return this.baseDataService.query(GET_CHANNELS);
+    }
+    getChannel(id) {
+        return this.baseDataService.query(GET_CHANNEL, {
+            id,
+        });
+    }
+    getActiveChannel(fetchPolicy) {
+        return this.baseDataService.query(GET_ACTIVE_CHANNEL, {}, fetchPolicy);
+    }
+    createChannel(input) {
+        return this.baseDataService.mutate(CREATE_CHANNEL, {
+            input,
+        });
+    }
+    updateChannel(input) {
+        return this.baseDataService.mutate(UPDATE_CHANNEL, {
+            input,
+        });
+    }
+    deleteChannel(id) {
+        return this.baseDataService.mutate(DELETE_CHANNEL, {
+            id,
+        });
+    }
+    getPaymentMethods(take = 10, skip = 0) {
+        return this.baseDataService.query(GET_PAYMENT_METHOD_LIST, {
+            options: {
+                skip,
+                take,
+            },
+        });
+    }
+    getPaymentMethod(id) {
+        return this.baseDataService.query(GET_PAYMENT_METHOD, {
+            id,
+        });
+    }
+    createPaymentMethod(input) {
+        return this.baseDataService.mutate(CREATE_PAYMENT_METHOD, {
+            input,
+        });
+    }
+    updatePaymentMethod(input) {
+        return this.baseDataService.mutate(UPDATE_PAYMENT_METHOD, {
+            input,
+        });
+    }
+    deletePaymentMethod(id, force) {
+        return this.baseDataService.mutate(DELETE_PAYMENT_METHOD, {
+            id,
+            force,
+        });
+    }
+    getPaymentMethodOperations() {
+        return this.baseDataService.query(GET_PAYMENT_METHOD_OPERATIONS);
+    }
+    getGlobalSettings(fetchPolicy) {
+        return this.baseDataService.query(GET_GLOBAL_SETTINGS, undefined, fetchPolicy);
+    }
+    updateGlobalSettings(input) {
+        return this.baseDataService.mutate(UPDATE_GLOBAL_SETTINGS, {
+            input,
+        });
+    }
+    getJob(id) {
+        return this.baseDataService.query(GET_JOB_INFO, {
+            id,
+        });
+    }
+    pollJobs(ids) {
+        return this.baseDataService.query(GET_JOBS_BY_ID, {
+            ids,
+        });
+    }
+    getAllJobs(options) {
+        return this.baseDataService.query(GET_JOBS_LIST, {
+            options,
+        }, 'cache-first');
+    }
+    getJobQueues() {
+        return this.baseDataService.query(GET_JOB_QUEUE_LIST);
+    }
+    getRunningJobs() {
+        return this.baseDataService.query(GET_JOBS_LIST, {
+            options: {
+                filter: {
+                    state: {
+                        eq: JobState.RUNNING,
+                    },
+                },
+            },
+        });
+    }
+    cancelJob(id) {
+        return this.baseDataService.mutate(CANCEL_JOB, {
+            id,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"settings-data.service.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/data/providers/settings-data.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { FetchPolicy, WatchQueryFetchPolicy } from '@apollo/client/core';\r\nimport { pick } from '@vendure/common/lib/pick';\r\n\r\nimport * as Codegen from '../../common/generated-types';\r\nimport { JobListOptions, JobState } from '../../common/generated-types';\r\nimport {\r\n    ADD_MEMBERS_TO_ZONE,\r\n    CANCEL_JOB,\r\n    CREATE_CHANNEL,\r\n    CREATE_COUNTRY,\r\n    CREATE_PAYMENT_METHOD,\r\n    CREATE_TAX_CATEGORY,\r\n    CREATE_TAX_RATE,\r\n    CREATE_ZONE,\r\n    DELETE_CHANNEL,\r\n    DELETE_COUNTRY,\r\n    DELETE_PAYMENT_METHOD,\r\n    DELETE_TAX_CATEGORY,\r\n    DELETE_TAX_RATE,\r\n    DELETE_ZONE,\r\n    GET_ACTIVE_CHANNEL,\r\n    GET_AVAILABLE_COUNTRIES,\r\n    GET_CHANNEL,\r\n    GET_CHANNELS,\r\n    GET_COUNTRY,\r\n    GET_COUNTRY_LIST,\r\n    GET_GLOBAL_SETTINGS,\r\n    GET_JOBS_BY_ID,\r\n    GET_JOBS_LIST,\r\n    GET_JOB_INFO,\r\n    GET_JOB_QUEUE_LIST,\r\n    GET_PAYMENT_METHOD,\r\n    GET_PAYMENT_METHOD_LIST,\r\n    GET_PAYMENT_METHOD_OPERATIONS,\r\n    GET_TAX_CATEGORIES,\r\n    GET_TAX_CATEGORY,\r\n    GET_TAX_RATE,\r\n    GET_TAX_RATE_LIST,\r\n    GET_TAX_RATE_LIST_SIMPLE,\r\n    GET_ZONES,\r\n    REMOVE_MEMBERS_FROM_ZONE,\r\n    UPDATE_CHANNEL,\r\n    UPDATE_COUNTRY,\r\n    UPDATE_GLOBAL_SETTINGS,\r\n    UPDATE_PAYMENT_METHOD,\r\n    UPDATE_TAX_CATEGORY,\r\n    UPDATE_TAX_RATE,\r\n    UPDATE_ZONE,\r\n} from '../definitions/settings-definitions';\r\n\r\nimport { BaseDataService } from './base-data.service';\r\n\r\nexport class SettingsDataService {\r\n    constructor(private baseDataService: BaseDataService) {}\r\n\r\n    getCountries(take: number = 10, skip: number = 0, filterTerm?: string) {\r\n        return this.baseDataService.query<\r\n            Codegen.GetCountryListQuery,\r\n            Codegen.GetCollectionListQueryVariables\r\n        >(GET_COUNTRY_LIST, {\r\n            options: {\r\n                take,\r\n                skip,\r\n                filter: {\r\n                    name: filterTerm ? { contains: filterTerm } : null,\r\n                },\r\n            },\r\n        });\r\n    }\r\n\r\n    getAvailableCountries() {\r\n        return this.baseDataService.query<Codegen.GetAvailableCountriesQuery>(GET_AVAILABLE_COUNTRIES);\r\n    }\r\n\r\n    getCountry(id: string) {\r\n        return this.baseDataService.query<Codegen.GetCountryQuery, Codegen.GetCountryQueryVariables>(\r\n            GET_COUNTRY,\r\n            { id },\r\n        );\r\n    }\r\n\r\n    createCountry(input: Codegen.CreateCountryInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.CreateCountryMutation,\r\n            Codegen.CreateCountryMutationVariables\r\n        >(CREATE_COUNTRY, {\r\n            input: pick(input, ['code', 'enabled', 'translations', 'customFields']),\r\n        });\r\n    }\r\n\r\n    updateCountry(input: Codegen.UpdateCountryInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.UpdateCountryMutation,\r\n            Codegen.UpdateCountryMutationVariables\r\n        >(UPDATE_COUNTRY, {\r\n            input: pick(input, ['id', 'code', 'enabled', 'translations', 'customFields']),\r\n        });\r\n    }\r\n\r\n    deleteCountry(id: string) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.DeleteCountryMutation,\r\n            Codegen.DeleteCountryMutationVariables\r\n        >(DELETE_COUNTRY, {\r\n            id,\r\n        });\r\n    }\r\n\r\n    getZones() {\r\n        return this.baseDataService.query<Codegen.GetZonesQuery>(GET_ZONES);\r\n    }\r\n\r\n    getZone(id: string) {\r\n        return this.baseDataService.query<Codegen.GetZoneQuery, Codegen.GetZoneQueryVariables>(GET_ZONES, {\r\n            id,\r\n        });\r\n    }\r\n\r\n    createZone(input: Codegen.CreateZoneInput) {\r\n        return this.baseDataService.mutate<Codegen.CreateZoneMutation, Codegen.CreateZoneMutationVariables>(\r\n            CREATE_ZONE,\r\n            {\r\n                input,\r\n            },\r\n        );\r\n    }\r\n\r\n    updateZone(input: Codegen.UpdateZoneInput) {\r\n        return this.baseDataService.mutate<Codegen.UpdateZoneMutation, Codegen.UpdateZoneMutationVariables>(\r\n            UPDATE_ZONE,\r\n            {\r\n                input,\r\n            },\r\n        );\r\n    }\r\n\r\n    deleteZone(id: string) {\r\n        return this.baseDataService.mutate<Codegen.DeleteZoneMutation, Codegen.DeleteZoneMutationVariables>(\r\n            DELETE_ZONE,\r\n            {\r\n                id,\r\n            },\r\n        );\r\n    }\r\n\r\n    addMembersToZone(zoneId: string, memberIds: string[]) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.AddMembersToZoneMutation,\r\n            Codegen.AddMembersToZoneMutationVariables\r\n        >(ADD_MEMBERS_TO_ZONE, {\r\n            zoneId,\r\n            memberIds,\r\n        });\r\n    }\r\n\r\n    removeMembersFromZone(zoneId: string, memberIds: string[]) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.RemoveMembersFromZoneMutation,\r\n            Codegen.RemoveMembersFromZoneMutationVariables\r\n        >(REMOVE_MEMBERS_FROM_ZONE, {\r\n            zoneId,\r\n            memberIds,\r\n        });\r\n    }\r\n\r\n    getTaxCategories() {\r\n        return this.baseDataService.query<Codegen.GetTaxCategoriesQuery>(GET_TAX_CATEGORIES);\r\n    }\r\n\r\n    getTaxCategory(id: string) {\r\n        return this.baseDataService.query<Codegen.GetTaxCategoryQuery, Codegen.GetTaxCategoryQueryVariables>(\r\n            GET_TAX_CATEGORY,\r\n            {\r\n                id,\r\n            },\r\n        );\r\n    }\r\n\r\n    createTaxCategory(input: Codegen.CreateTaxCategoryInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.CreateTaxCategoryMutation,\r\n            Codegen.CreateTaxCategoryMutationVariables\r\n        >(CREATE_TAX_CATEGORY, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    updateTaxCategory(input: Codegen.UpdateTaxCategoryInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.UpdateTaxCategoryMutation,\r\n            Codegen.UpdateTaxCategoryMutationVariables\r\n        >(UPDATE_TAX_CATEGORY, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    deleteTaxCategory(id: string) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.DeleteTaxCategoryMutation,\r\n            Codegen.DeleteTaxRateMutationVariables\r\n        >(DELETE_TAX_CATEGORY, {\r\n            id,\r\n        });\r\n    }\r\n\r\n    getTaxRates(take: number = 10, skip: number = 0, fetchPolicy?: FetchPolicy) {\r\n        return this.baseDataService.query<Codegen.GetTaxRateListQuery, Codegen.GetTaxRateListQueryVariables>(\r\n            GET_TAX_RATE_LIST,\r\n            {\r\n                options: {\r\n                    take,\r\n                    skip,\r\n                },\r\n            },\r\n            fetchPolicy,\r\n        );\r\n    }\r\n\r\n    getTaxRatesSimple(take: number = 10, skip: number = 0, fetchPolicy?: FetchPolicy) {\r\n        return this.baseDataService.query<\r\n            Codegen.GetTaxRateListSimpleQuery,\r\n            Codegen.GetTaxRateListSimpleQueryVariables\r\n        >(\r\n            GET_TAX_RATE_LIST_SIMPLE,\r\n            {\r\n                options: {\r\n                    take,\r\n                    skip,\r\n                },\r\n            },\r\n            fetchPolicy,\r\n        );\r\n    }\r\n\r\n    getTaxRate(id: string) {\r\n        return this.baseDataService.query<Codegen.GetTaxRateQuery, Codegen.GetTaxRateQueryVariables>(\r\n            GET_TAX_RATE,\r\n            {\r\n                id,\r\n            },\r\n        );\r\n    }\r\n\r\n    createTaxRate(input: Codegen.CreateTaxRateInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.CreateTaxRateMutation,\r\n            Codegen.CreateTaxRateMutationVariables\r\n        >(CREATE_TAX_RATE, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    updateTaxRate(input: Codegen.UpdateTaxRateInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.UpdateTaxRateMutation,\r\n            Codegen.UpdateTaxRateMutationVariables\r\n        >(UPDATE_TAX_RATE, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    deleteTaxRate(id: string) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.DeleteTaxRateMutation,\r\n            Codegen.DeleteTaxRateMutationVariables\r\n        >(DELETE_TAX_RATE, {\r\n            id,\r\n        });\r\n    }\r\n\r\n    getChannels() {\r\n        return this.baseDataService.query<Codegen.GetChannelsQuery>(GET_CHANNELS);\r\n    }\r\n\r\n    getChannel(id: string) {\r\n        return this.baseDataService.query<Codegen.GetChannelQuery, Codegen.GetChannelQueryVariables>(\r\n            GET_CHANNEL,\r\n            {\r\n                id,\r\n            },\r\n        );\r\n    }\r\n\r\n    getActiveChannel(fetchPolicy?: FetchPolicy) {\r\n        return this.baseDataService.query<\r\n            Codegen.GetActiveChannelQuery,\r\n            Codegen.GetActiveChannelQueryVariables\r\n        >(GET_ACTIVE_CHANNEL, {}, fetchPolicy);\r\n    }\r\n\r\n    createChannel(input: Codegen.CreateChannelInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.CreateChannelMutation,\r\n            Codegen.CreateChannelMutationVariables\r\n        >(CREATE_CHANNEL, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    updateChannel(input: Codegen.UpdateChannelInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.UpdateChannelMutation,\r\n            Codegen.UpdateChannelMutationVariables\r\n        >(UPDATE_CHANNEL, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    deleteChannel(id: string) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.DeleteChannelMutation,\r\n            Codegen.DeleteChannelMutationVariables\r\n        >(DELETE_CHANNEL, {\r\n            id,\r\n        });\r\n    }\r\n\r\n    getPaymentMethods(take: number = 10, skip: number = 0) {\r\n        return this.baseDataService.query<\r\n            Codegen.GetPaymentMethodListQuery,\r\n            Codegen.GetPaymentMethodListQueryVariables\r\n        >(GET_PAYMENT_METHOD_LIST, {\r\n            options: {\r\n                skip,\r\n                take,\r\n            },\r\n        });\r\n    }\r\n\r\n    getPaymentMethod(id: string) {\r\n        return this.baseDataService.query<\r\n            Codegen.GetPaymentMethodQuery,\r\n            Codegen.GetPaymentMethodQueryVariables\r\n        >(GET_PAYMENT_METHOD, {\r\n            id,\r\n        });\r\n    }\r\n\r\n    createPaymentMethod(input: Codegen.CreatePaymentMethodInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.CreatePaymentMethodMutation,\r\n            Codegen.CreatePaymentMethodMutationVariables\r\n        >(CREATE_PAYMENT_METHOD, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    updatePaymentMethod(input: Codegen.UpdatePaymentMethodInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.UpdatePaymentMethodMutation,\r\n            Codegen.UpdatePaymentMethodMutationVariables\r\n        >(UPDATE_PAYMENT_METHOD, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    deletePaymentMethod(id: string, force: boolean) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.DeletePaymentMethodMutation,\r\n            Codegen.DeletePaymentMethodMutationVariables\r\n        >(DELETE_PAYMENT_METHOD, {\r\n            id,\r\n            force,\r\n        });\r\n    }\r\n\r\n    getPaymentMethodOperations() {\r\n        return this.baseDataService.query<Codegen.GetPaymentMethodOperationsQuery>(\r\n            GET_PAYMENT_METHOD_OPERATIONS,\r\n        );\r\n    }\r\n\r\n    getGlobalSettings(fetchPolicy?: WatchQueryFetchPolicy) {\r\n        return this.baseDataService.query<Codegen.GetGlobalSettingsQuery>(\r\n            GET_GLOBAL_SETTINGS,\r\n            undefined,\r\n            fetchPolicy,\r\n        );\r\n    }\r\n\r\n    updateGlobalSettings(input: Codegen.UpdateGlobalSettingsInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.UpdateGlobalSettingsMutation,\r\n            Codegen.UpdateGlobalSettingsMutationVariables\r\n        >(UPDATE_GLOBAL_SETTINGS, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    getJob(id: string) {\r\n        return this.baseDataService.query<Codegen.GetJobInfoQuery, Codegen.GetJobInfoQueryVariables>(\r\n            GET_JOB_INFO,\r\n            {\r\n                id,\r\n            },\r\n        );\r\n    }\r\n\r\n    pollJobs(ids: string[]) {\r\n        return this.baseDataService.query<Codegen.GetJobsByIdQuery, Codegen.GetJobsByIdQueryVariables>(\r\n            GET_JOBS_BY_ID,\r\n            {\r\n                ids,\r\n            },\r\n        );\r\n    }\r\n\r\n    getAllJobs(options?: JobListOptions) {\r\n        return this.baseDataService.query<Codegen.GetAllJobsQuery, Codegen.GetAllJobsQueryVariables>(\r\n            GET_JOBS_LIST,\r\n            {\r\n                options,\r\n            },\r\n            'cache-first',\r\n        );\r\n    }\r\n\r\n    getJobQueues() {\r\n        return this.baseDataService.query<Codegen.GetJobQueueListQuery>(GET_JOB_QUEUE_LIST);\r\n    }\r\n\r\n    getRunningJobs() {\r\n        return this.baseDataService.query<Codegen.GetAllJobsQuery, Codegen.GetAllJobsQueryVariables>(\r\n            GET_JOBS_LIST,\r\n            {\r\n                options: {\r\n                    filter: {\r\n                        state: {\r\n                            eq: JobState.RUNNING,\r\n                        },\r\n                    },\r\n                },\r\n            },\r\n        );\r\n    }\r\n\r\n    cancelJob(id: string) {\r\n        return this.baseDataService.mutate<Codegen.CancelJobMutation, Codegen.CancelJobMutationVariables>(\r\n            CANCEL_JOB,\r\n            {\r\n                id,\r\n            },\r\n        );\r\n    }\r\n}\r\n"]}

package/esm2020/core/data/providers/shipping-method-data.service.mjs

@@ -0,0 +1,66 @@
+import { pick } from '@vendure/common/lib/pick';
+import { CREATE_SHIPPING_METHOD, DELETE_SHIPPING_METHOD, GET_SHIPPING_METHOD, GET_SHIPPING_METHOD_LIST, GET_SHIPPING_METHOD_OPERATIONS, TEST_ELIGIBLE_SHIPPING_METHODS, TEST_SHIPPING_METHOD, UPDATE_SHIPPING_METHOD, } from '../definitions/shipping-definitions';
+export class ShippingMethodDataService {
+    constructor(baseDataService) {
+        this.baseDataService = baseDataService;
+    }
+    getShippingMethods(take = 10, skip = 0) {
+        return this.baseDataService.query(GET_SHIPPING_METHOD_LIST, {
+            options: {
+                take,
+                skip,
+            },
+        });
+    }
+    getShippingMethod(id) {
+        return this.baseDataService.query(GET_SHIPPING_METHOD, {
+            id,
+        });
+    }
+    getShippingMethodOperations() {
+        return this.baseDataService.query(GET_SHIPPING_METHOD_OPERATIONS);
+    }
+    createShippingMethod(input) {
+        const variables = {
+            input: pick(input, [
+                'code',
+                'checker',
+                'calculator',
+                'fulfillmentHandler',
+                'customFields',
+                'translations',
+            ]),
+        };
+        return this.baseDataService.mutate(CREATE_SHIPPING_METHOD, variables);
+    }
+    updateShippingMethod(input) {
+        const variables = {
+            input: pick(input, [
+                'id',
+                'code',
+                'checker',
+                'calculator',
+                'fulfillmentHandler',
+                'customFields',
+                'translations',
+            ]),
+        };
+        return this.baseDataService.mutate(UPDATE_SHIPPING_METHOD, variables);
+    }
+    deleteShippingMethod(id) {
+        return this.baseDataService.mutate(DELETE_SHIPPING_METHOD, {
+            id,
+        });
+    }
+    testShippingMethod(input) {
+        return this.baseDataService.query(TEST_SHIPPING_METHOD, {
+            input,
+        });
+    }
+    testEligibleShippingMethods(input) {
+        return this.baseDataService.query(TEST_ELIGIBLE_SHIPPING_METHODS, {
+            input,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/core/data/query-result.js → esm2020/core/data/query-result.mjs}

@@ -74,4 +74,4 @@ export class QueryResult {
         return this.stream$.pipe(map(mapFn));
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-result.js","sourceRoot":"","sources":["../../../../src/lib/core/src/data/query-result.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApolloQueryResult, NetworkStatus } from '@apollo/client/core';\r\nimport { notNullOrUndefined } from '@vendure/common/lib/shared-utils';\r\nimport { Apollo, QueryRef } from 'apollo-angular';\r\nimport { merge, Observable, Subject } from 'rxjs';\r\nimport { distinctUntilChanged, filter, finalize, map, skip, take, takeUntil, tap } from 'rxjs/operators';\r\n\r\nimport { GetUserStatus } from '../common/generated-types';\r\n\r\nimport { GET_USER_STATUS } from './definitions/client-definitions';\r\n\r\n/**\r\n * @description\r\n * This class wraps the Apollo Angular QueryRef object and exposes some getters\r\n * for convenience.\r\n *\r\n * @docsCategory providers\r\n * @docsPage DataService\r\n */\r\nexport class QueryResult<T, V = Record<string, any>> {\r\n    constructor(private queryRef: QueryRef<T, V>, private apollo: Apollo) {\r\n        this.valueChanges = queryRef.valueChanges;\r\n    }\r\n\r\n    completed$ = new Subject();\r\n    private valueChanges: Observable<ApolloQueryResult<T>>;\r\n\r\n    /**\r\n     * @description\r\n     * Re-fetch this query whenever the active Channel changes.\r\n     */\r\n    refetchOnChannelChange(): QueryResult<T, V> {\r\n        const userStatus$ = this.apollo.watchQuery<GetUserStatus.Query>({\r\n            query: GET_USER_STATUS,\r\n        }).valueChanges;\r\n        const activeChannelId$ = userStatus$.pipe(\r\n            map(data => data.data.userStatus.activeChannelId),\r\n            filter(notNullOrUndefined),\r\n            distinctUntilChanged(),\r\n            skip(1),\r\n            takeUntil(this.completed$),\r\n        );\r\n        const loggedOut$ = userStatus$.pipe(\r\n            map(data => data.data.userStatus.isLoggedIn),\r\n            distinctUntilChanged(),\r\n            skip(1),\r\n            filter(isLoggedIn => !isLoggedIn),\r\n            takeUntil(this.completed$),\r\n        );\r\n\r\n        this.valueChanges = merge(activeChannelId$, this.queryRef.valueChanges).pipe(\r\n            tap(val => {\r\n                if (typeof val === 'string') {\r\n                    new Promise(resolve => setTimeout(resolve, 50)).then(() => this.queryRef.refetch());\r\n                }\r\n            }),\r\n            filter<any>(val => typeof val !== 'string'),\r\n            takeUntil(loggedOut$),\r\n            takeUntil(this.completed$),\r\n        );\r\n        this.queryRef.valueChanges = this.valueChanges;\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Returns an Observable which emits a single result and then completes.\r\n     */\r\n    get single$(): Observable<T> {\r\n        return this.valueChanges.pipe(\r\n            filter(result => result.networkStatus === NetworkStatus.ready),\r\n            take(1),\r\n            map(result => result.data),\r\n            finalize(() => {\r\n                this.completed$.next();\r\n                this.completed$.complete();\r\n            }),\r\n        );\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Returns an Observable which emits until unsubscribed.\r\n     */\r\n    get stream$(): Observable<T> {\r\n        return this.valueChanges.pipe(\r\n            filter(result => result.networkStatus === NetworkStatus.ready),\r\n            map(result => result.data),\r\n            finalize(() => {\r\n                this.completed$.next();\r\n                this.completed$.complete();\r\n            }),\r\n        );\r\n    }\r\n\r\n    get ref(): QueryRef<T, V> {\r\n        return this.queryRef;\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Returns a single-result Observable after applying the map function.\r\n     */\r\n    mapSingle<R>(mapFn: (item: T) => R): Observable<R> {\r\n        return this.single$.pipe(map(mapFn));\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Returns a multiple-result Observable after applying the map function.\r\n     */\r\n    mapStream<R>(mapFn: (item: T) => R): Observable<R> {\r\n        return this.stream$.pipe(map(mapFn));\r\n    }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-result.js","sourceRoot":"","sources":["../../../../src/lib/core/src/data/query-result.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApolloQueryResult, NetworkStatus } from '@apollo/client/core';\r\nimport { notNullOrUndefined } from '@vendure/common/lib/shared-utils';\r\nimport { Apollo, QueryRef } from 'apollo-angular';\r\nimport { merge, Observable, Subject } from 'rxjs';\r\nimport { distinctUntilChanged, filter, finalize, map, skip, take, takeUntil, tap } from 'rxjs/operators';\r\n\r\nimport { GetUserStatusQuery } from '../common/generated-types';\r\n\r\nimport { GET_USER_STATUS } from './definitions/client-definitions';\r\n\r\n/**\r\n * @description\r\n * This class wraps the Apollo Angular QueryRef object and exposes some getters\r\n * for convenience.\r\n *\r\n * @docsCategory providers\r\n * @docsPage DataService\r\n */\r\nexport class QueryResult<T, V = Record<string, any>> {\r\n    constructor(private queryRef: QueryRef<T, V>, private apollo: Apollo) {\r\n        this.valueChanges = queryRef.valueChanges;\r\n    }\r\n\r\n    completed$ = new Subject<void>();\r\n    private valueChanges: Observable<ApolloQueryResult<T>>;\r\n\r\n    /**\r\n     * @description\r\n     * Re-fetch this query whenever the active Channel changes.\r\n     */\r\n    refetchOnChannelChange(): QueryResult<T, V> {\r\n        const userStatus$ = this.apollo.watchQuery<GetUserStatusQuery>({\r\n            query: GET_USER_STATUS,\r\n        }).valueChanges;\r\n        const activeChannelId$ = userStatus$.pipe(\r\n            map(data => data.data.userStatus.activeChannelId),\r\n            filter(notNullOrUndefined),\r\n            distinctUntilChanged(),\r\n            skip(1),\r\n            takeUntil(this.completed$),\r\n        );\r\n        const loggedOut$ = userStatus$.pipe(\r\n            map(data => data.data.userStatus.isLoggedIn),\r\n            distinctUntilChanged(),\r\n            skip(1),\r\n            filter(isLoggedIn => !isLoggedIn),\r\n            takeUntil(this.completed$),\r\n        );\r\n\r\n        this.valueChanges = merge(activeChannelId$, this.queryRef.valueChanges).pipe(\r\n            tap(val => {\r\n                if (typeof val === 'string') {\r\n                    new Promise(resolve => setTimeout(resolve, 50)).then(() => this.queryRef.refetch());\r\n                }\r\n            }),\r\n            filter<any>(val => typeof val !== 'string'),\r\n            takeUntil(loggedOut$),\r\n            takeUntil(this.completed$),\r\n        );\r\n        this.queryRef.valueChanges = this.valueChanges;\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Returns an Observable which emits a single result and then completes.\r\n     */\r\n    get single$(): Observable<T> {\r\n        return this.valueChanges.pipe(\r\n            filter(result => result.networkStatus === NetworkStatus.ready),\r\n            take(1),\r\n            map(result => result.data),\r\n            finalize(() => {\r\n                this.completed$.next();\r\n                this.completed$.complete();\r\n            }),\r\n        );\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Returns an Observable which emits until unsubscribed.\r\n     */\r\n    get stream$(): Observable<T> {\r\n        return this.valueChanges.pipe(\r\n            filter(result => result.networkStatus === NetworkStatus.ready),\r\n            map(result => result.data),\r\n            finalize(() => {\r\n                this.completed$.next();\r\n                this.completed$.complete();\r\n            }),\r\n        );\r\n    }\r\n\r\n    get ref(): QueryRef<T, V> {\r\n        return this.queryRef;\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Returns a single-result Observable after applying the map function.\r\n     */\r\n    mapSingle<R>(mapFn: (item: T) => R): Observable<R> {\r\n        return this.single$.pipe(map(mapFn));\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Returns a multiple-result Observable after applying the map function.\r\n     */\r\n    mapStream<R>(mapFn: (item: T) => R): Observable<R> {\r\n        return this.stream$.pipe(map(mapFn));\r\n    }\r\n}\r\n"]}

package/esm2020/core/data/server-config.mjs

@@ -0,0 +1,74 @@
+import { Injectable } from '@angular/core';
+import { lastValueFrom } from 'rxjs';
+import { GET_GLOBAL_SETTINGS, GET_SERVER_CONFIG } from './definitions/settings-definitions';
+import { BaseDataService } from './providers/base-data.service';
+import * as i0 from "@angular/core";
+export function initializeServerConfigService(serverConfigService) {
+    return serverConfigService.init();
+}
+/**
+ * A service which fetches the config from the server upon initialization, and then provides that config
+ * to the components which require it.
+ */
+export class ServerConfigService {
+    constructor(injector) {
+        this.injector = injector;
+        this._serverConfig = {};
+    }
+    get baseDataService() {
+        return this.injector.get(BaseDataService);
+    }
+    /**
+     * Fetches the ServerConfig. Should be run as part of the app bootstrap process by attaching
+     * to the Angular APP_INITIALIZER token.
+     */
+    init() {
+        return () => this.getServerConfig();
+    }
+    /**
+     * Fetch the ServerConfig. Should be run on app init (in case user is already logged in) and on successful login.
+     */
+    getServerConfig() {
+        return lastValueFrom(this.baseDataService.query(GET_SERVER_CONFIG).single$).then(result => {
+            this._serverConfig = result.globalSettings.serverConfig;
+        }, err => {
+            // Let the error fall through to be caught by the http interceptor.
+        });
+    }
+    getAvailableLanguages() {
+        return this.baseDataService
+            .query(GET_GLOBAL_SETTINGS, {}, 'cache-first')
+            .mapSingle(res => res.globalSettings.availableLanguages);
+    }
+    /**
+     * When any of the GlobalSettings are modified, this method should be called to update the Apollo cache.
+     */
+    refreshGlobalSettings() {
+        return this.baseDataService.query(GET_GLOBAL_SETTINGS, {}, 'network-only')
+            .single$;
+    }
+    /**
+     * Retrieves the custom field configs for the given entity type.
+     */
+    getCustomFieldsFor(type) {
+        return this.serverConfig.customFieldConfig[type] || [];
+    }
+    getOrderProcessStates() {
+        return this.serverConfig.orderProcess;
+    }
+    getPermittedAssetTypes() {
+        return this.serverConfig.permittedAssetTypes;
+    }
+    getPermissionDefinitions() {
+        return this.serverConfig.permissions;
+    }
+    get serverConfig() {
+        return this._serverConfig;
+    }
+}
+ServerConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ServerConfigService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+ServerConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ServerConfigService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ServerConfigService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/data/utils/add-custom-fields.mjs

@@ -0,0 +1,84 @@
+import { Kind, } from 'graphql';
+/**
+ * Given a GraphQL AST (DocumentNode), this function looks for fragment definitions and adds and configured
+ * custom fields to those fragments.
+ */
+export function addCustomFields(documentNode, customFields) {
+    const fragmentDefs = documentNode.definitions.filter(isFragmentDefinition);
+    for (const fragmentDef of fragmentDefs) {
+        let entityType = fragmentDef.typeCondition.name.value;
+        if (entityType === 'OrderAddress') {
+            // OrderAddress is a special case of the Address entity, and shares its custom fields
+            // so we treat it as an alias
+            entityType = 'Address';
+        }
+        const customFieldsForType = customFields[entityType];
+        if (customFieldsForType && customFieldsForType.length) {
+            fragmentDef.selectionSet.selections.push({
+                name: {
+                    kind: Kind.NAME,
+                    value: 'customFields',
+                },
+                kind: Kind.FIELD,
+                selectionSet: {
+                    kind: Kind.SELECTION_SET,
+                    selections: customFieldsForType.map(customField => {
+                        return {
+                            kind: Kind.FIELD,
+                            name: {
+                                kind: Kind.NAME,
+                                value: customField.name,
+                            },
+                            // For "relation" custom fields, we need to also select
+                            // all the scalar fields of the related type
+                            ...(customField.type === 'relation'
+                                ? {
+                                    selectionSet: {
+                                        kind: Kind.SELECTION_SET,
+                                        selections: customField.scalarFields.map(f => ({
+                                            kind: Kind.FIELD,
+                                            name: { kind: Kind.NAME, value: f },
+                                        })),
+                                    },
+                                }
+                                : {}),
+                        };
+                    }),
+                },
+            });
+            const localeStrings = customFieldsForType.filter(field => field.type === 'localeString');
+            const translationsField = fragmentDef.selectionSet.selections
+                .filter(isFieldNode)
+                .find(field => field.name.value === 'translations');
+            if (localeStrings.length && translationsField && translationsField.selectionSet) {
+                translationsField.selectionSet.selections.push({
+                    name: {
+                        kind: Kind.NAME,
+                        value: 'customFields',
+                    },
+                    kind: Kind.FIELD,
+                    selectionSet: {
+                        kind: Kind.SELECTION_SET,
+                        selections: localeStrings.map(customField => {
+                            return {
+                                kind: Kind.FIELD,
+                                name: {
+                                    kind: Kind.NAME,
+                                    value: customField.name,
+                                },
+                            };
+                        }),
+                    },
+                });
+            }
+        }
+    }
+    return documentNode;
+}
+function isFragmentDefinition(value) {
+    return value.kind === Kind.FRAGMENT_DEFINITION;
+}
+function isFieldNode(value) {
+    return value.kind === Kind.FIELD;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"add-custom-fields.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/data/utils/add-custom-fields.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    DefinitionNode,\r\n    DocumentNode,\r\n    FieldNode,\r\n    FragmentDefinitionNode,\r\n    Kind,\r\n    SelectionNode,\r\n} from 'graphql';\r\n\r\nimport { CustomFields, RelationCustomFieldFragment } from '../../common/generated-types';\r\n\r\n/**\r\n * Given a GraphQL AST (DocumentNode), this function looks for fragment definitions and adds and configured\r\n * custom fields to those fragments.\r\n */\r\nexport function addCustomFields(documentNode: DocumentNode, customFields: CustomFields): DocumentNode {\r\n    const fragmentDefs = documentNode.definitions.filter(isFragmentDefinition);\r\n\r\n    for (const fragmentDef of fragmentDefs) {\r\n        let entityType = fragmentDef.typeCondition.name.value as keyof Pick<\r\n            CustomFields,\r\n            Exclude<keyof CustomFields, '__typename'>\r\n        >;\r\n\r\n        if (entityType === ('OrderAddress' as any)) {\r\n            // OrderAddress is a special case of the Address entity, and shares its custom fields\r\n            // so we treat it as an alias\r\n            entityType = 'Address';\r\n        }\r\n\r\n        const customFieldsForType = customFields[entityType];\r\n        if (customFieldsForType && customFieldsForType.length) {\r\n            (fragmentDef.selectionSet.selections as SelectionNode[]).push({\r\n                name: {\r\n                    kind: Kind.NAME,\r\n                    value: 'customFields',\r\n                },\r\n                kind: Kind.FIELD,\r\n                selectionSet: {\r\n                    kind: Kind.SELECTION_SET,\r\n                    selections: customFieldsForType.map(customField => {\r\n                        return {\r\n                            kind: Kind.FIELD,\r\n                            name: {\r\n                                kind: Kind.NAME,\r\n                                value: customField.name,\r\n                            },\r\n                            // For \"relation\" custom fields, we need to also select\r\n                            // all the scalar fields of the related type\r\n                            ...(customField.type === 'relation'\r\n                                ? {\r\n                                      selectionSet: {\r\n                                          kind: Kind.SELECTION_SET,\r\n                                          selections: (\r\n                                              customField as RelationCustomFieldFragment\r\n                                          ).scalarFields.map(f => ({\r\n                                              kind: Kind.FIELD,\r\n                                              name: { kind: Kind.NAME, value: f },\r\n                                          })),\r\n                                      },\r\n                                  }\r\n                                : {}),\r\n                        } as FieldNode;\r\n                    }),\r\n                },\r\n            });\r\n\r\n            const localeStrings = customFieldsForType.filter(field => field.type === 'localeString');\r\n\r\n            const translationsField = fragmentDef.selectionSet.selections\r\n                .filter(isFieldNode)\r\n                .find(field => field.name.value === 'translations');\r\n\r\n            if (localeStrings.length && translationsField && translationsField.selectionSet) {\r\n                (translationsField.selectionSet.selections as SelectionNode[]).push({\r\n                    name: {\r\n                        kind: Kind.NAME,\r\n                        value: 'customFields',\r\n                    },\r\n                    kind: Kind.FIELD,\r\n                    selectionSet: {\r\n                        kind: Kind.SELECTION_SET,\r\n                        selections: localeStrings.map(customField => {\r\n                            return {\r\n                                kind: Kind.FIELD,\r\n                                name: {\r\n                                    kind: Kind.NAME,\r\n                                    value: customField.name,\r\n                                },\r\n                            } as FieldNode;\r\n                        }),\r\n                    },\r\n                });\r\n            }\r\n        }\r\n    }\r\n\r\n    return documentNode;\r\n}\r\n\r\nfunction isFragmentDefinition(value: DefinitionNode): value is FragmentDefinitionNode {\r\n    return value.kind === Kind.FRAGMENT_DEFINITION;\r\n}\r\n\r\nfunction isFieldNode(value: SelectionNode): value is FieldNode {\r\n    return value.kind === Kind.FIELD;\r\n}\r\n"]}