feat(core): Allow PaginatedList filters to use logical OR operator

Closes #1149

packages/asset-server-plugin/e2e/graphql/generated-e2e-asset-server-plugin-types.ts

@@ -106,10 +106,16 @@ export type AdministratorList = PaginatedList & {
 };
 
 export type AdministratorListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<AdministratorSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<AdministratorFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type AdministratorPaymentInput = {
@@ -187,10 +193,16 @@ export type AssetList = PaginatedList & {
 export type AssetListOptions = {
     tags?: Maybe<Array<Scalars['String']>>;
     tagsOperator?: Maybe<LogicalOperator>;
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<AssetSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<AssetFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type AssetSortParameter = {
@@ -369,10 +381,16 @@ export type CollectionList = PaginatedList & {
 };
 
 export type CollectionListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<CollectionSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<CollectionFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 /**
@@ -478,10 +496,16 @@ export type CountryList = PaginatedList & {
 };
 
 export type CountryListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<CountrySortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<CountryFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type CountrySortParameter = {
@@ -1167,10 +1191,16 @@ export type CustomerGroupList = PaginatedList & {
 };
 
 export type CustomerGroupListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<CustomerGroupSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<CustomerGroupFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type CustomerGroupSortParameter = {
@@ -1186,10 +1216,16 @@ export type CustomerList = PaginatedList & {
 };
 
 export type CustomerListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<CustomerSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<CustomerFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type CustomerSortParameter = {
@@ -1347,10 +1383,16 @@ export type FacetList = PaginatedList & {
 };
 
 export type FacetListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<FacetSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<FacetFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type FacetSortParameter = {
@@ -1505,10 +1547,16 @@ export type HistoryEntryList = PaginatedList & {
 };
 
 export type HistoryEntryListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<HistoryEntrySortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<HistoryEntryFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type HistoryEntrySortParameter = {
@@ -1644,10 +1692,16 @@ export type JobList = PaginatedList & {
 };
 
 export type JobListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<JobSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<JobFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type JobQueue = {
@@ -3005,10 +3059,16 @@ export type OrderList = PaginatedList & {
 };
 
 export type OrderListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<OrderSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<OrderFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type OrderModification = Node & {
@@ -3122,10 +3182,16 @@ export type PaymentMethodList = PaginatedList & {
 };
 
 export type PaymentMethodListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<PaymentMethodSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<PaymentMethodFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 /**
@@ -3405,10 +3471,16 @@ export type ProductList = PaginatedList & {
 };
 
 export type ProductListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<ProductSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<ProductFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type ProductOption = Node & {
@@ -3560,10 +3632,16 @@ export type ProductVariantList = PaginatedList & {
 };
 
 export type ProductVariantListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<ProductVariantSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<ProductVariantFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type ProductVariantSortParameter = {
@@ -3627,10 +3705,16 @@ export type PromotionList = PaginatedList & {
 };
 
 export type PromotionListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<PromotionSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<PromotionFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type PromotionSortParameter = {
@@ -4036,10 +4120,16 @@ export type RoleList = PaginatedList & {
 };
 
 export type RoleListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<RoleSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<RoleFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type RoleSortParameter = {
@@ -4188,10 +4278,16 @@ export type ShippingMethodList = PaginatedList & {
 };
 
 export type ShippingMethodListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<ShippingMethodSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<ShippingMethodFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type ShippingMethodQuote = {
@@ -4357,10 +4453,16 @@ export type TagList = PaginatedList & {
 };
 
 export type TagListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<TagSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<TagFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type TagSortParameter = {
@@ -4409,10 +4511,16 @@ export type TaxRateList = PaginatedList & {
 };
 
 export type TaxRateListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<TaxRateSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<TaxRateFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type TaxRateSortParameter = {

packages/common/src/generated-shop-types.ts

@@ -197,10 +197,16 @@ export type CollectionList = PaginatedList & {
 };
 
 export type CollectionListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<CollectionSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<CollectionFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 /**
@@ -767,10 +773,16 @@ export type CustomerList = PaginatedList & {
 };
 
 export type CustomerListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<CustomerSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<CustomerFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type CustomerSortParameter = {
@@ -908,10 +920,16 @@ export type FacetList = PaginatedList & {
 };
 
 export type FacetListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<FacetSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<FacetFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type FacetSortParameter = {
@@ -1031,10 +1049,16 @@ export type HistoryEntryList = PaginatedList & {
 };
 
 export type HistoryEntryListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<HistoryEntrySortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<HistoryEntryFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type HistoryEntrySortParameter = {
@@ -1965,10 +1989,16 @@ export type OrderList = PaginatedList & {
 };
 
 export type OrderListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<OrderSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<OrderFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 /** Returned when attempting to modify the contents of an Order that is not in the `AddingItems` state. */
@@ -2340,10 +2370,16 @@ export type ProductList = PaginatedList & {
 };
 
 export type ProductListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<ProductSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<ProductFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type ProductOption = Node & {
@@ -2454,10 +2490,16 @@ export type ProductVariantList = PaginatedList & {
 };
 
 export type ProductVariantListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<ProductVariantSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<ProductVariantFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type ProductVariantSortParameter = {

packages/common/src/generated-types.ts

@@ -103,10 +103,16 @@ export type AdministratorList = PaginatedList & {
 };
 
 export type AdministratorListOptions = {
+  /** Skips the first n results, for use in pagination */
   skip?: Maybe<Scalars['Int']>;
+  /** Takes n results, for use in pagination */
   take?: Maybe<Scalars['Int']>;
+  /** Specifies which properties to sort the results by */
   sort?: Maybe<AdministratorSortParameter>;
+  /** Allows the results to be filtered */
   filter?: Maybe<AdministratorFilterParameter>;
+  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+  filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type AdministratorPaymentInput = {
@@ -187,10 +193,16 @@ export type AssetList = PaginatedList & {
 export type AssetListOptions = {
   tags?: Maybe<Array<Scalars['String']>>;
   tagsOperator?: Maybe<LogicalOperator>;
+  /** Skips the first n results, for use in pagination */
   skip?: Maybe<Scalars['Int']>;
+  /** Takes n results, for use in pagination */
   take?: Maybe<Scalars['Int']>;
+  /** Specifies which properties to sort the results by */
   sort?: Maybe<AssetSortParameter>;
+  /** Allows the results to be filtered */
   filter?: Maybe<AssetFilterParameter>;
+  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+  filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type AssetSortParameter = {
@@ -372,10 +384,16 @@ export type CollectionList = PaginatedList & {
 };
 
 export type CollectionListOptions = {
+  /** Skips the first n results, for use in pagination */
   skip?: Maybe<Scalars['Int']>;
+  /** Takes n results, for use in pagination */
   take?: Maybe<Scalars['Int']>;
+  /** Specifies which properties to sort the results by */
   sort?: Maybe<CollectionSortParameter>;
+  /** Allows the results to be filtered */
   filter?: Maybe<CollectionFilterParameter>;
+  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+  filterOperator?: Maybe<LogicalOperator>;
 };
 
 /**
@@ -490,10 +508,16 @@ export type CountryList = PaginatedList & {
 };
 
 export type CountryListOptions = {
+  /** Skips the first n results, for use in pagination */
   skip?: Maybe<Scalars['Int']>;
+  /** Takes n results, for use in pagination */
   take?: Maybe<Scalars['Int']>;
+  /** Specifies which properties to sort the results by */
   sort?: Maybe<CountrySortParameter>;
+  /** Allows the results to be filtered */
   filter?: Maybe<CountryFilterParameter>;
+  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+  filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type CountrySortParameter = {
@@ -1182,10 +1206,16 @@ export type CustomerGroupList = PaginatedList & {
 };
 
 export type CustomerGroupListOptions = {
+  /** Skips the first n results, for use in pagination */
   skip?: Maybe<Scalars['Int']>;
+  /** Takes n results, for use in pagination */
   take?: Maybe<Scalars['Int']>;
+  /** Specifies which properties to sort the results by */
   sort?: Maybe<CustomerGroupSortParameter>;
+  /** Allows the results to be filtered */
   filter?: Maybe<CustomerGroupFilterParameter>;
+  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+  filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type CustomerGroupSortParameter = {
@@ -1202,10 +1232,16 @@ export type CustomerList = PaginatedList & {
 };
 
 export type CustomerListOptions = {
+  /** Skips the first n results, for use in pagination */
   skip?: Maybe<Scalars['Int']>;
+  /** Takes n results, for use in pagination */
   take?: Maybe<Scalars['Int']>;
+  /** Specifies which properties to sort the results by */
   sort?: Maybe<CustomerSortParameter>;
+  /** Allows the results to be filtered */
   filter?: Maybe<CustomerFilterParameter>;
+  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+  filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type CustomerSortParameter = {
@@ -1371,10 +1407,16 @@ export type FacetList = PaginatedList & {
 };
 
 export type FacetListOptions = {
+  /** Skips the first n results, for use in pagination */
   skip?: Maybe<Scalars['Int']>;
+  /** Takes n results, for use in pagination */
   take?: Maybe<Scalars['Int']>;
+  /** Specifies which properties to sort the results by */
   sort?: Maybe<FacetSortParameter>;
+  /** Allows the results to be filtered */
   filter?: Maybe<FacetFilterParameter>;
+  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+  filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type FacetSortParameter = {
@@ -1539,10 +1581,16 @@ export type HistoryEntryList = PaginatedList & {
 };
 
 export type HistoryEntryListOptions = {
+  /** Skips the first n results, for use in pagination */
   skip?: Maybe<Scalars['Int']>;
+  /** Takes n results, for use in pagination */
   take?: Maybe<Scalars['Int']>;
+  /** Specifies which properties to sort the results by */
   sort?: Maybe<HistoryEntrySortParameter>;
+  /** Allows the results to be filtered */
   filter?: Maybe<HistoryEntryFilterParameter>;
+  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+  filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type HistoryEntrySortParameter = {
@@ -1689,10 +1737,16 @@ export type JobList = PaginatedList & {
 };
 
 export type JobListOptions = {
+  /** Skips the first n results, for use in pagination */
   skip?: Maybe<Scalars['Int']>;
+  /** Takes n results, for use in pagination */
   take?: Maybe<Scalars['Int']>;
+  /** Specifies which properties to sort the results by */
   sort?: Maybe<JobSortParameter>;
+  /** Allows the results to be filtered */
   filter?: Maybe<JobFilterParameter>;
+  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+  filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type JobQueue = {
@@ -3167,10 +3221,16 @@ export type OrderList = PaginatedList & {
 };
 
 export type OrderListOptions = {
+  /** Skips the first n results, for use in pagination */
   skip?: Maybe<Scalars['Int']>;
+  /** Takes n results, for use in pagination */
   take?: Maybe<Scalars['Int']>;
+  /** Specifies which properties to sort the results by */
   sort?: Maybe<OrderSortParameter>;
+  /** Allows the results to be filtered */
   filter?: Maybe<OrderFilterParameter>;
+  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+  filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type OrderModification = Node & {
@@ -3292,10 +3352,16 @@ export type PaymentMethodList = PaginatedList & {
 };
 
 export type PaymentMethodListOptions = {
+  /** Skips the first n results, for use in pagination */
   skip?: Maybe<Scalars['Int']>;
+  /** Takes n results, for use in pagination */
   take?: Maybe<Scalars['Int']>;
+  /** Specifies which properties to sort the results by */
   sort?: Maybe<PaymentMethodSortParameter>;
+  /** Allows the results to be filtered */
   filter?: Maybe<PaymentMethodFilterParameter>;
+  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+  filterOperator?: Maybe<LogicalOperator>;
 };
 
 /**
@@ -3584,10 +3650,16 @@ export type ProductList = PaginatedList & {
 };
 
 export type ProductListOptions = {
+  /** Skips the first n results, for use in pagination */
   skip?: Maybe<Scalars['Int']>;
+  /** Takes n results, for use in pagination */
   take?: Maybe<Scalars['Int']>;
+  /** Specifies which properties to sort the results by */
   sort?: Maybe<ProductSortParameter>;
+  /** Allows the results to be filtered */
   filter?: Maybe<ProductFilterParameter>;
+  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+  filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type ProductOption = Node & {
@@ -3748,10 +3820,16 @@ export type ProductVariantList = PaginatedList & {
 };
 
 export type ProductVariantListOptions = {
+  /** Skips the first n results, for use in pagination */
   skip?: Maybe<Scalars['Int']>;
+  /** Takes n results, for use in pagination */
   take?: Maybe<Scalars['Int']>;
+  /** Specifies which properties to sort the results by */
   sort?: Maybe<ProductVariantSortParameter>;
+  /** Allows the results to be filtered */
   filter?: Maybe<ProductVariantFilterParameter>;
+  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+  filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type ProductVariantSortParameter = {
@@ -3818,10 +3896,16 @@ export type PromotionList = PaginatedList & {
 };
 
 export type PromotionListOptions = {
+  /** Skips the first n results, for use in pagination */
   skip?: Maybe<Scalars['Int']>;
+  /** Takes n results, for use in pagination */
   take?: Maybe<Scalars['Int']>;
+  /** Specifies which properties to sort the results by */
   sort?: Maybe<PromotionSortParameter>;
+  /** Allows the results to be filtered */
   filter?: Maybe<PromotionFilterParameter>;
+  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+  filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type PromotionSortParameter = {
@@ -4271,10 +4355,16 @@ export type RoleList = PaginatedList & {
 };
 
 export type RoleListOptions = {
+  /** Skips the first n results, for use in pagination */
   skip?: Maybe<Scalars['Int']>;
+  /** Takes n results, for use in pagination */
   take?: Maybe<Scalars['Int']>;
+  /** Specifies which properties to sort the results by */
   sort?: Maybe<RoleSortParameter>;
+  /** Allows the results to be filtered */
   filter?: Maybe<RoleFilterParameter>;
+  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+  filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type RoleSortParameter = {
@@ -4428,10 +4518,16 @@ export type ShippingMethodList = PaginatedList & {
 };
 
 export type ShippingMethodListOptions = {
+  /** Skips the first n results, for use in pagination */
   skip?: Maybe<Scalars['Int']>;
+  /** Takes n results, for use in pagination */
   take?: Maybe<Scalars['Int']>;
+  /** Specifies which properties to sort the results by */
   sort?: Maybe<ShippingMethodSortParameter>;
+  /** Allows the results to be filtered */
   filter?: Maybe<ShippingMethodFilterParameter>;
+  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+  filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type ShippingMethodQuote = {
@@ -4607,10 +4703,16 @@ export type TagList = PaginatedList & {
 };
 
 export type TagListOptions = {
+  /** Skips the first n results, for use in pagination */
   skip?: Maybe<Scalars['Int']>;
+  /** Takes n results, for use in pagination */
   take?: Maybe<Scalars['Int']>;
+  /** Specifies which properties to sort the results by */
   sort?: Maybe<TagSortParameter>;
+  /** Allows the results to be filtered */
   filter?: Maybe<TagFilterParameter>;
+  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+  filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type TagSortParameter = {
@@ -4663,10 +4765,16 @@ export type TaxRateList = PaginatedList & {
 };
 
 export type TaxRateListOptions = {
+  /** Skips the first n results, for use in pagination */
   skip?: Maybe<Scalars['Int']>;
+  /** Takes n results, for use in pagination */
   take?: Maybe<Scalars['Int']>;
+  /** Specifies which properties to sort the results by */
   sort?: Maybe<TaxRateSortParameter>;
+  /** Allows the results to be filtered */
   filter?: Maybe<TaxRateFilterParameter>;
+  /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+  filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type TaxRateSortParameter = {

packages/core/e2e/graphql/generated-e2e-admin-types.ts

@@ -106,10 +106,16 @@ export type AdministratorList = PaginatedList & {
 };
 
 export type AdministratorListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<AdministratorSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<AdministratorFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type AdministratorPaymentInput = {
@@ -187,10 +193,16 @@ export type AssetList = PaginatedList & {
 export type AssetListOptions = {
     tags?: Maybe<Array<Scalars['String']>>;
     tagsOperator?: Maybe<LogicalOperator>;
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<AssetSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<AssetFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type AssetSortParameter = {
@@ -369,10 +381,16 @@ export type CollectionList = PaginatedList & {
 };
 
 export type CollectionListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<CollectionSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<CollectionFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 /**
@@ -478,10 +496,16 @@ export type CountryList = PaginatedList & {
 };
 
 export type CountryListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<CountrySortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<CountryFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type CountrySortParameter = {
@@ -1167,10 +1191,16 @@ export type CustomerGroupList = PaginatedList & {
 };
 
 export type CustomerGroupListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<CustomerGroupSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<CustomerGroupFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type CustomerGroupSortParameter = {
@@ -1186,10 +1216,16 @@ export type CustomerList = PaginatedList & {
 };
 
 export type CustomerListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<CustomerSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<CustomerFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type CustomerSortParameter = {
@@ -1347,10 +1383,16 @@ export type FacetList = PaginatedList & {
 };
 
 export type FacetListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<FacetSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<FacetFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type FacetSortParameter = {
@@ -1505,10 +1547,16 @@ export type HistoryEntryList = PaginatedList & {
 };
 
 export type HistoryEntryListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<HistoryEntrySortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<HistoryEntryFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type HistoryEntrySortParameter = {
@@ -1644,10 +1692,16 @@ export type JobList = PaginatedList & {
 };
 
 export type JobListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<JobSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<JobFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type JobQueue = {
@@ -3005,10 +3059,16 @@ export type OrderList = PaginatedList & {
 };
 
 export type OrderListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<OrderSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<OrderFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type OrderModification = Node & {
@@ -3122,10 +3182,16 @@ export type PaymentMethodList = PaginatedList & {
 };
 
 export type PaymentMethodListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<PaymentMethodSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<PaymentMethodFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 /**
@@ -3405,10 +3471,16 @@ export type ProductList = PaginatedList & {
 };
 
 export type ProductListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<ProductSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<ProductFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type ProductOption = Node & {
@@ -3560,10 +3632,16 @@ export type ProductVariantList = PaginatedList & {
 };
 
 export type ProductVariantListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<ProductVariantSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<ProductVariantFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type ProductVariantSortParameter = {
@@ -3627,10 +3705,16 @@ export type PromotionList = PaginatedList & {
 };
 
 export type PromotionListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<PromotionSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<PromotionFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type PromotionSortParameter = {
@@ -4036,10 +4120,16 @@ export type RoleList = PaginatedList & {
 };
 
 export type RoleListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<RoleSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<RoleFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type RoleSortParameter = {
@@ -4188,10 +4278,16 @@ export type ShippingMethodList = PaginatedList & {
 };
 
 export type ShippingMethodListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<ShippingMethodSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<ShippingMethodFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type ShippingMethodQuote = {
@@ -4357,10 +4453,16 @@ export type TagList = PaginatedList & {
 };
 
 export type TagListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<TagSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<TagFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type TagSortParameter = {
@@ -4409,10 +4511,16 @@ export type TaxRateList = PaginatedList & {
 };
 
 export type TaxRateListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<TaxRateSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<TaxRateFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type TaxRateSortParameter = {

packages/core/e2e/graphql/generated-e2e-shop-types.ts

@@ -186,10 +186,16 @@ export type CollectionList = PaginatedList & {
 };
 
 export type CollectionListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<CollectionSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<CollectionFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 /**
@@ -738,10 +744,16 @@ export type CustomerList = PaginatedList & {
 };
 
 export type CustomerListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<CustomerSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<CustomerFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type CustomerSortParameter = {
@@ -873,10 +885,16 @@ export type FacetList = PaginatedList & {
 };
 
 export type FacetListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<FacetSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<FacetFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type FacetSortParameter = {
@@ -988,10 +1006,16 @@ export type HistoryEntryList = PaginatedList & {
 };
 
 export type HistoryEntryListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<HistoryEntrySortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<HistoryEntryFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type HistoryEntrySortParameter = {
@@ -1901,10 +1925,16 @@ export type OrderList = PaginatedList & {
 };
 
 export type OrderListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<OrderSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<OrderFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 /** Returned when attempting to modify the contents of an Order that is not in the `AddingItems` state. */
@@ -2262,10 +2292,16 @@ export type ProductList = PaginatedList & {
 };
 
 export type ProductListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<ProductSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<ProductFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type ProductOption = Node & {
@@ -2369,10 +2405,16 @@ export type ProductVariantList = PaginatedList & {
 };
 
 export type ProductVariantListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<ProductVariantSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<ProductVariantFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type ProductVariantSortParameter = {

packages/core/e2e/list-query-builder.e2e-spec.ts

@@ -1,3 +1,4 @@
+import { LogicalOperator } from '@vendure/common/lib/generated-types';
 import { mergeConfig } from '@vendure/core';
 import { createTestEnvironment } from '@vendure/testing';
 import gql from 'graphql-tag';
@@ -500,6 +501,93 @@ describe('ListQueryBuilder', () => {
         });
     });
 
+    describe('multiple filters with filterOperator', () => {
+        it('default AND', async () => {
+            const { testEntities } = await adminClient.query(GET_LIST, {
+                options: {
+                    filter: {
+                        description: {
+                            contains: 'Lorem',
+                        },
+                        active: {
+                            eq: false,
+                        },
+                    },
+                },
+            });
+
+            expect(getItemLabels(testEntities.items)).toEqual([]);
+        });
+
+        it('explicit AND', async () => {
+            const { testEntities } = await adminClient.query(GET_LIST, {
+                options: {
+                    filter: {
+                        description: {
+                            contains: 'Lorem',
+                        },
+                        active: {
+                            eq: false,
+                        },
+                    },
+                    filterOperator: LogicalOperator.AND,
+                },
+            });
+
+            expect(getItemLabels(testEntities.items)).toEqual([]);
+        });
+
+        it('explicit OR', async () => {
+            const { testEntities } = await adminClient.query(GET_LIST, {
+                options: {
+                    filter: {
+                        description: {
+                            contains: 'Lorem',
+                        },
+                        active: {
+                            eq: false,
+                        },
+                    },
+                    filterOperator: LogicalOperator.OR,
+                },
+            });
+
+            expect(getItemLabels(testEntities.items)).toEqual(['A', 'C', 'E', 'F']);
+        });
+
+        it('explicit OR with 3 filters', async () => {
+            const { testEntities } = await adminClient.query(GET_LIST, {
+                options: {
+                    filter: {
+                        description: {
+                            contains: 'eiusmod',
+                        },
+                        active: {
+                            eq: false,
+                        },
+                        order: {
+                            lt: 3,
+                        },
+                    },
+                    filterOperator: LogicalOperator.OR,
+                },
+            });
+
+            expect(getItemLabels(testEntities.items)).toEqual(['A', 'B', 'C', 'D', 'E', 'F']);
+        });
+
+        it('explicit OR with empty filters object', async () => {
+            const { testEntities } = await adminClient.query(GET_LIST, {
+                options: {
+                    filter: {},
+                    filterOperator: LogicalOperator.OR,
+                },
+            });
+
+            expect(getItemLabels(testEntities.items)).toEqual(['A', 'B', 'C', 'D', 'E', 'F']);
+        });
+    });
+
     describe('sorting', () => {
         it('sort by string', async () => {
             const { testEntities } = await adminClient.query(GET_LIST, {

packages/core/src/api/config/generate-list-options.spec.ts

@@ -66,9 +66,16 @@ describe('generateListOptions()', () => {
         expect(printType(result.getType('PersonListOptions')!)).toBe(
             removeLeadingWhitespace(`
                    input PersonListOptions {
+                     """Skips the first n results, for use in pagination"""
                      skip: Int
+
+                     """Takes n results, for use in pagination"""
                      take: Int
+
+                     """Specifies which properties to sort the results by"""
                      sort: PersonSortParameter
+
+                     """Allows the results to be filtered"""
                      filter: PersonFilterParameter
                    }`),
         );
@@ -165,9 +172,16 @@ describe('generateListOptions()', () => {
         expect(printType(result.getType('PersonListOptions')!)).toBe(
             removeLeadingWhitespace(`
                     input PersonListOptions {
+                      """Skips the first n results, for use in pagination"""
                       skip: Int
+
+                      """Takes n results, for use in pagination"""
                       take: Int
+
+                      """Specifies which properties to sort the results by"""
                       sort: PersonSortParameter
+
+                      """Allows the results to be filtered"""
                       filter: PersonFilterParameter
                     }`),
         );
@@ -200,9 +214,17 @@ describe('generateListOptions()', () => {
             removeLeadingWhitespace(`
                     input PersonListOptions {
                       categoryId: ID
+
+                      """Skips the first n results, for use in pagination"""
                       skip: Int
+
+                      """Takes n results, for use in pagination"""
                       take: Int
+
+                      """Specifies which properties to sort the results by"""
                       sort: PersonSortParameter
+
+                      """Allows the results to be filtered"""
                       filter: PersonFilterParameter
                     }`),
         );
@@ -282,9 +304,16 @@ describe('generateListOptions()', () => {
         expect(printType(result.getType('OrderListOptions')!)).toBe(
             removeLeadingWhitespace(`
                    input OrderListOptions {
+                     """Skips the first n results, for use in pagination"""
                      skip: Int
+
+                     """Takes n results, for use in pagination"""
                      take: Int
+
+                     """Specifies which properties to sort the results by"""
                      sort: OrderSortParameter
+
+                     """Allows the results to be filtered"""
                      filter: OrderFilterParameter
                    }`),
         );

packages/core/src/api/config/generate-list-options.ts

@@ -30,6 +30,7 @@ export function generateListOptions(typeDefsOrSchema: string | GraphQLSchema): G
     if (!queryType) {
         return schema;
     }
+    const logicalOperatorEnum = schema.getType('LogicalOperator');
     const objectTypes = Object.values(schema.getTypeMap()).filter(isObjectType);
     const allFields = objectTypes.reduce((fields, type) => {
         const typeFields = Object.values(type.getFields()).filter(f => isListQueryType(f.type));
@@ -49,10 +50,25 @@ export function generateListOptions(typeDefsOrSchema: string | GraphQLSchema): G
             const generatedListOptions = new GraphQLInputObjectType({
                 name: `${targetTypeName}ListOptions`,
                 fields: {
-                    skip: { type: GraphQLInt },
-                    take: { type: GraphQLInt },
-                    sort: { type: sortParameter },
-                    filter: { type: filterParameter },
+                    skip: {
+                        type: GraphQLInt,
+                        description: 'Skips the first n results, for use in pagination',
+                    },
+                    take: { type: GraphQLInt, description: 'Takes n results, for use in pagination' },
+                    sort: {
+                        type: sortParameter,
+                        description: 'Specifies which properties to sort the results by',
+                    },
+                    filter: { type: filterParameter, description: 'Allows the results to be filtered' },
+                    ...(logicalOperatorEnum
+                        ? {
+                              filterOperator: {
+                                  type: logicalOperatorEnum as GraphQLEnumType,
+                                  description:
+                                      'Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND.',
+                              },
+                          }
+                        : {}),
                     ...(existingListOptions ? existingListOptions.getFields() : {}),
                 },
             });

packages/core/src/common/types/common-types.ts

@@ -1,3 +1,4 @@
+import { LogicalOperator } from '@vendure/common/lib/generated-types';
 import { Type } from '@vendure/common/lib/shared-types';
 
 import { VendureEntity } from '../../entity/base/base.entity';
@@ -69,6 +70,7 @@ export interface ListQueryOptions<T extends VendureEntity> {
     skip?: number | null;
     sort?: NullOptionals<SortParameter<T>> | null;
     filter?: NullOptionals<FilterParameter<T>> | null;
+    filterOperator?: LogicalOperator;
 }
 
 /**

packages/core/src/service/helpers/list-query-builder/list-query-builder.ts

@@ -1,4 +1,5 @@
 import { Injectable, OnApplicationBootstrap } from '@nestjs/common';
+import { LogicalOperator } from '@vendure/common/lib/generated-types';
 import { ID, Type } from '@vendure/common/lib/shared-types';
 import { unique } from '@vendure/common/lib/unique';
 import { Brackets, FindConditions, FindManyOptions, FindOneOptions, SelectQueryBuilder } from 'typeorm';
@@ -187,9 +188,22 @@ export class ListQueryBuilder implements OnApplicationBootstrap {
         );
         const filter = parseFilterParams(rawConnection, entity, options.filter, customPropertyMap);
 
-        filter.forEach(({ clause, parameters }) => {
-            qb.andWhere(clause, parameters);
-        });
+        if (filter.length) {
+            const filterOperator = options.filterOperator ?? LogicalOperator.AND;
+            if (filterOperator === LogicalOperator.AND) {
+                filter.forEach(({ clause, parameters }) => {
+                    qb.andWhere(clause, parameters);
+                });
+            } else {
+                qb.andWhere(
+                    new Brackets(qb1 => {
+                        filter.forEach(({ clause, parameters }) => {
+                            qb1.orWhere(clause, parameters);
+                        });
+                    }),
+                );
+            }
+        }
 
         if (extendedOptions.channelId) {
             const channelFilter = parseChannelParam(rawConnection, entity, extendedOptions.channelId);

packages/elasticsearch-plugin/e2e/graphql/generated-e2e-elasticsearch-plugin-types.ts

@@ -106,10 +106,16 @@ export type AdministratorList = PaginatedList & {
 };
 
 export type AdministratorListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<AdministratorSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<AdministratorFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type AdministratorPaymentInput = {
@@ -187,10 +193,16 @@ export type AssetList = PaginatedList & {
 export type AssetListOptions = {
     tags?: Maybe<Array<Scalars['String']>>;
     tagsOperator?: Maybe<LogicalOperator>;
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<AssetSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<AssetFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type AssetSortParameter = {
@@ -369,10 +381,16 @@ export type CollectionList = PaginatedList & {
 };
 
 export type CollectionListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<CollectionSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<CollectionFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 /**
@@ -478,10 +496,16 @@ export type CountryList = PaginatedList & {
 };
 
 export type CountryListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<CountrySortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<CountryFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type CountrySortParameter = {
@@ -1167,10 +1191,16 @@ export type CustomerGroupList = PaginatedList & {
 };
 
 export type CustomerGroupListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<CustomerGroupSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<CustomerGroupFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type CustomerGroupSortParameter = {
@@ -1186,10 +1216,16 @@ export type CustomerList = PaginatedList & {
 };
 
 export type CustomerListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<CustomerSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<CustomerFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type CustomerSortParameter = {
@@ -1347,10 +1383,16 @@ export type FacetList = PaginatedList & {
 };
 
 export type FacetListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<FacetSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<FacetFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type FacetSortParameter = {
@@ -1505,10 +1547,16 @@ export type HistoryEntryList = PaginatedList & {
 };
 
 export type HistoryEntryListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<HistoryEntrySortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<HistoryEntryFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type HistoryEntrySortParameter = {
@@ -1644,10 +1692,16 @@ export type JobList = PaginatedList & {
 };
 
 export type JobListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<JobSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<JobFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type JobQueue = {
@@ -3005,10 +3059,16 @@ export type OrderList = PaginatedList & {
 };
 
 export type OrderListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<OrderSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<OrderFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type OrderModification = Node & {
@@ -3122,10 +3182,16 @@ export type PaymentMethodList = PaginatedList & {
 };
 
 export type PaymentMethodListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<PaymentMethodSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<PaymentMethodFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 /**
@@ -3405,10 +3471,16 @@ export type ProductList = PaginatedList & {
 };
 
 export type ProductListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<ProductSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<ProductFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type ProductOption = Node & {
@@ -3560,10 +3632,16 @@ export type ProductVariantList = PaginatedList & {
 };
 
 export type ProductVariantListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<ProductVariantSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<ProductVariantFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type ProductVariantSortParameter = {
@@ -3627,10 +3705,16 @@ export type PromotionList = PaginatedList & {
 };
 
 export type PromotionListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<PromotionSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<PromotionFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type PromotionSortParameter = {
@@ -4036,10 +4120,16 @@ export type RoleList = PaginatedList & {
 };
 
 export type RoleListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<RoleSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<RoleFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type RoleSortParameter = {
@@ -4188,10 +4278,16 @@ export type ShippingMethodList = PaginatedList & {
 };
 
 export type ShippingMethodListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<ShippingMethodSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<ShippingMethodFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type ShippingMethodQuote = {
@@ -4357,10 +4453,16 @@ export type TagList = PaginatedList & {
 };
 
 export type TagListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<TagSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<TagFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type TagSortParameter = {
@@ -4409,10 +4511,16 @@ export type TaxRateList = PaginatedList & {
 };
 
 export type TaxRateListOptions = {
+    /** Skips the first n results, for use in pagination */
     skip?: Maybe<Scalars['Int']>;
+    /** Takes n results, for use in pagination */
     take?: Maybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
     sort?: Maybe<TaxRateSortParameter>;
+    /** Allows the results to be filtered */
     filter?: Maybe<TaxRateFilterParameter>;
+    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
+    filterOperator?: Maybe<LogicalOperator>;
 };
 
 export type TaxRateSortParameter = {