fix(medusa): Admin validator filtering and pagination (#9748)

**What**
Fix usage of $and and $or operator and pagination inclusion

.changeset/early-deers-happen.md

@@ -0,0 +1,5 @@
+---
+"@medusajs/medusa": patch
+---
+
+fix(medusa): Admin validator  filtering and pagination

packages/medusa/src/api/admin/api-keys/validators.ts

@@ -5,28 +5,29 @@ import {
   createOperatorMap,
   createSelectParams,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export const AdminGetApiKeyParams = createSelectParams()
 
+export const AdminGetApiKeysParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  title: z.union([z.string(), z.array(z.string())]).optional(),
+  token: z.union([z.string(), z.array(z.string())]).optional(),
+  type: z.nativeEnum(ApiKeyType).optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+  revoked_at: createOperatorMap().optional(),
+})
+
 export type AdminGetApiKeysParamsType = z.infer<typeof AdminGetApiKeysParams>
 export const AdminGetApiKeysParams = createFindParams({
   offset: 0,
   limit: 20,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    title: z.union([z.string(), z.array(z.string())]).optional(),
-    token: z.union([z.string(), z.array(z.string())]).optional(),
-    type: z.nativeEnum(ApiKeyType).optional(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    revoked_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetApiKeysParams.array()).optional(),
-    $or: z.lazy(() => AdminGetApiKeysParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetApiKeysParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetApiKeysParamsFields))
 
 export type AdminCreateApiKeyType = z.infer<typeof AdminCreateApiKey>
 export const AdminCreateApiKey = z.object({

packages/medusa/src/api/admin/campaigns/validators.ts

@@ -5,9 +5,22 @@ import {
   createSelectParams,
   WithAdditionalData,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export const AdminGetCampaignParams = createSelectParams()
 
+export const AdminGetCampaignsParamsFields = z
+  .object({
+    q: z.string().optional(),
+    campaign_identifier: z.string().optional(),
+    budget: z
+      .object({
+        currency_code: z.string().optional(),
+      })
+      .optional(),
+  })
+  .strict()
+
 export type AdminGetCampaignsParamsType = z.infer<
   typeof AdminGetCampaignsParams
 >
@@ -15,20 +28,8 @@ export const AdminGetCampaignsParams = createFindParams({
   offset: 0,
   limit: 50,
 })
-  .merge(
-    z.object({
-      q: z.string().optional(),
-      campaign_identifier: z.string().optional(),
-      budget: z
-        .object({
-          currency_code: z.string().optional(),
-        })
-        .optional(),
-      $and: z.lazy(() => AdminGetCampaignsParams.array()).optional(),
-      $or: z.lazy(() => AdminGetCampaignsParams.array()).optional(),
-    })
-  )
-  .strict()
+  .merge(AdminGetCampaignsParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetCampaignsParamsFields).strict())
 
 const CreateCampaignBudget = z
   .object({

packages/medusa/src/api/admin/collections/validators.ts

@@ -4,27 +4,28 @@ import {
   createOperatorMap,
   createSelectParams,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export const AdminGetCollectionParams = createSelectParams()
 
+export const AdminGetCollectionsParamsFields = z.object({
+  q: z.string().optional(),
+  title: z.union([z.string(), z.array(z.string())]).optional(),
+  handle: z.union([z.string(), z.array(z.string())]).optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 export type AdminGetCollectionsParamsType = z.infer<
   typeof AdminGetCollectionsParams
 >
 export const AdminGetCollectionsParams = createFindParams({
   offset: 0,
   limit: 10,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    title: z.union([z.string(), z.array(z.string())]).optional(),
-    handle: z.union([z.string(), z.array(z.string())]).optional(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetCollectionsParams.array()).optional(),
-    $or: z.lazy(() => AdminGetCollectionsParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetCollectionsParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetCollectionsParamsFields))
 
 export type AdminCreateCollectionType = z.infer<typeof AdminCreateCollection>
 export const AdminCreateCollection = z.object({

packages/medusa/src/api/admin/currencies/validators.ts

@@ -1,19 +1,20 @@
 import { z } from "zod"
 import { createFindParams, createSelectParams } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export const AdminGetCurrencyParams = createSelectParams()
 
+export const AdminGetCurrenciesParamsFields = z.object({
+  q: z.string().optional(),
+  code: z.union([z.string(), z.array(z.string())]).optional(),
+})
+
 export type AdminGetCurrenciesParamsType = z.infer<
   typeof AdminGetCurrenciesParams
 >
 export const AdminGetCurrenciesParams = createFindParams({
   offset: 0,
   limit: 200,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    code: z.union([z.string(), z.array(z.string())]).optional(),
-    $and: z.lazy(() => AdminGetCurrenciesParams.array()).optional(),
-    $or: z.lazy(() => AdminGetCurrenciesParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetCurrenciesParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetCurrenciesParamsFields))

packages/medusa/src/api/admin/customer-groups/validators.ts

@@ -4,6 +4,7 @@ import {
   createOperatorMap,
   createSelectParams,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export type AdminGetCustomerGroupParamsType = z.infer<
   typeof AdminGetCustomerGroupParams
@@ -30,28 +31,28 @@ export const AdminCustomerInGroupFilters = z.object({
   deleted_at: createOperatorMap().optional(),
 })
 
+export const AdminGetCustomerGroupsParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  name: z.union([z.string(), z.array(z.string())]).optional(),
+  customers: z
+    .union([z.string(), z.array(z.string()), AdminCustomerInGroupFilters])
+    .optional(),
+  created_by: z.union([z.string(), z.array(z.string())]).optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 export type AdminGetCustomerGroupsParamsType = z.infer<
   typeof AdminGetCustomerGroupsParams
 >
 export const AdminGetCustomerGroupsParams = createFindParams({
   limit: 50,
   offset: 0,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    name: z.union([z.string(), z.array(z.string())]).optional(),
-    customers: z
-      .union([z.string(), z.array(z.string()), AdminCustomerInGroupFilters])
-      .optional(),
-    created_by: z.union([z.string(), z.array(z.string())]).optional(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetCustomerGroupsParams.array()).optional(),
-    $or: z.lazy(() => AdminGetCustomerGroupsParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetCustomerGroupsParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetCustomerGroupsParamsFields))
 
 export type AdminCreateCustomerGroupType = z.infer<
   typeof AdminCreateCustomerGroup

packages/medusa/src/api/admin/customers/validators.ts

@@ -1,5 +1,8 @@
 import { z } from "zod"
-import { booleanString } from "../../utils/common-validators"
+import {
+  applyAndAndOrOperators,
+  booleanString,
+} from "../../utils/common-validators"
 import {
   createFindParams,
   createOperatorMap,
@@ -17,33 +20,33 @@ export const AdminCustomerGroupInCustomerParams = z.object({
   deleted_at: createOperatorMap().optional(),
 })
 
+export const AdminCustomersParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  email: z.union([z.string(), z.array(z.string())]).optional(),
+  groups: z
+    .union([
+      AdminCustomerGroupInCustomerParams,
+      z.string(),
+      z.array(z.string()),
+    ])
+    .optional(),
+  company_name: z.union([z.string(), z.array(z.string())]).optional(),
+  first_name: z.union([z.string(), z.array(z.string())]).optional(),
+  last_name: z.union([z.string(), z.array(z.string())]).optional(),
+  has_account: booleanString().optional(),
+  created_by: z.union([z.string(), z.array(z.string())]).optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 export const AdminCustomersParams = createFindParams({
   limit: 50,
   offset: 0,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    email: z.union([z.string(), z.array(z.string())]).optional(),
-    groups: z
-      .union([
-        AdminCustomerGroupInCustomerParams,
-        z.string(),
-        z.array(z.string()),
-      ])
-      .optional(),
-    company_name: z.union([z.string(), z.array(z.string())]).optional(),
-    first_name: z.union([z.string(), z.array(z.string())]).optional(),
-    last_name: z.union([z.string(), z.array(z.string())]).optional(),
-    has_account: booleanString().optional(),
-    created_by: z.union([z.string(), z.array(z.string())]).optional(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminCustomersParams.array()).optional(),
-    $or: z.lazy(() => AdminCustomersParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminCustomersParamsFields)
+  .merge(applyAndAndOrOperators(AdminCustomersParamsFields))
 
 export const CreateCustomer = z.object({
   email: z.string().email().nullish(),

packages/medusa/src/api/admin/draft-orders/validators.ts

@@ -1,5 +1,9 @@
 import { z } from "zod"
-import { AddressPayload, BigNumberInput } from "../../utils/common-validators"
+import {
+  AddressPayload,
+  applyAndAndOrOperators,
+  BigNumberInput,
+} from "../../utils/common-validators"
 import {
   createFindParams,
   createSelectParams,
@@ -9,17 +13,17 @@ import {
 export type AdminGetOrderParamsType = z.infer<typeof AdminGetOrderParams>
 export const AdminGetOrderParams = createSelectParams()
 
+export const AdminGetOrdersParamsFields = z.object({
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+})
+
 export type AdminGetOrdersParamsType = z.infer<typeof AdminGetOrdersParams>
 export const AdminGetOrdersParams = createFindParams({
   limit: 50,
   offset: 0,
-}).merge(
-  z.object({
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    $and: z.lazy(() => AdminGetOrdersParams.array()).optional(),
-    $or: z.lazy(() => AdminGetOrdersParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetOrdersParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetOrdersParamsFields))
 
 enum Status {
   completed = "completed",

packages/medusa/src/api/admin/inventory-items/validators.ts

@@ -1,5 +1,8 @@
 import { z } from "zod"
-import { booleanString } from "../../utils/common-validators"
+import {
+  applyAndAndOrOperators,
+  booleanString,
+} from "../../utils/common-validators"
 import {
   createFindParams,
   createOperatorMap,
@@ -11,6 +14,26 @@ export type AdminGetInventoryItemParamsType = z.infer<
 >
 export const AdminGetInventoryItemParams = createSelectParams()
 
+export const AdminGetInventoryItemsParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  sku: z.union([z.string(), z.array(z.string())]).optional(),
+  origin_country: z.union([z.string(), z.array(z.string())]).optional(),
+  mid_code: z.union([z.string(), z.array(z.string())]).optional(),
+  hs_code: z.union([z.string(), z.array(z.string())]).optional(),
+  material: z.union([z.string(), z.array(z.string())]).optional(),
+  requires_shipping: booleanString().optional(),
+  weight: createOperatorMap(z.number(), parseFloat).optional(),
+  length: createOperatorMap(z.number(), parseFloat).optional(),
+  height: createOperatorMap(z.number(), parseFloat).optional(),
+  width: createOperatorMap(z.number(), parseFloat).optional(),
+  location_levels: z
+    .object({
+      location_id: z.union([z.string(), z.array(z.string())]).optional(),
+    })
+    .optional(),
+})
+
 export type AdminGetInventoryItemsParamsType = z.infer<
   typeof AdminGetInventoryItemsParams
 >
@@ -18,29 +41,8 @@ export const AdminGetInventoryItemsParams = createFindParams({
   limit: 20,
   offset: 0,
 })
-  .merge(
-    z.object({
-      q: z.string().optional(),
-      id: z.union([z.string(), z.array(z.string())]).optional(),
-      sku: z.union([z.string(), z.array(z.string())]).optional(),
-      origin_country: z.union([z.string(), z.array(z.string())]).optional(),
-      mid_code: z.union([z.string(), z.array(z.string())]).optional(),
-      hs_code: z.union([z.string(), z.array(z.string())]).optional(),
-      material: z.union([z.string(), z.array(z.string())]).optional(),
-      requires_shipping: booleanString().optional(),
-      weight: createOperatorMap(z.number(), parseFloat).optional(),
-      length: createOperatorMap(z.number(), parseFloat).optional(),
-      height: createOperatorMap(z.number(), parseFloat).optional(),
-      width: createOperatorMap(z.number(), parseFloat).optional(),
-      location_levels: z
-        .object({
-          location_id: z.union([z.string(), z.array(z.string())]).optional(),
-        })
-        .optional(),
-      $and: z.lazy(() => AdminGetInventoryItemsParams.array()).optional(),
-      $or: z.lazy(() => AdminGetInventoryItemsParams.array()).optional(),
-    })
-  )
+  .merge(AdminGetInventoryItemsParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetInventoryItemsParamsFields))
   .strict()
 
 export type AdminGetInventoryLocationLevelParamsType = z.infer<
@@ -48,21 +50,19 @@ export type AdminGetInventoryLocationLevelParamsType = z.infer<
 >
 export const AdminGetInventoryLocationLevelParams = createSelectParams()
 
+export const AdminGetInventoryLocationLevelsParamsFields = z.object({
+  location_id: z.union([z.string(), z.array(z.string())]).optional(),
+})
+
 export type AdminGetInventoryLocationLevelsParamsType = z.infer<
   typeof AdminGetInventoryLocationLevelsParams
 >
 export const AdminGetInventoryLocationLevelsParams = createFindParams({
   limit: 50,
   offset: 0,
-}).merge(
-  z.object({
-    location_id: z.union([z.string(), z.array(z.string())]).optional(),
-    $and: z
-      .lazy(() => AdminGetInventoryLocationLevelsParams.array())
-      .optional(),
-    $or: z.lazy(() => AdminGetInventoryLocationLevelsParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetInventoryLocationLevelsParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetInventoryLocationLevelsParamsFields))
 
 export type AdminCreateInventoryLocationLevelType = z.infer<
   typeof AdminCreateInventoryLocationLevel

packages/medusa/src/api/admin/invites/validators.ts

@@ -4,26 +4,27 @@ import {
   createOperatorMap,
   createSelectParams,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export type AdminGetInviteParamsType = z.infer<typeof AdminGetInviteParams>
 export const AdminGetInviteParams = createSelectParams()
 
+export const AdminGetInvitesParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  email: z.union([z.string(), z.array(z.string())]).optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 export type AdminGetInvitesParamsType = z.infer<typeof AdminGetInvitesParams>
 export const AdminGetInvitesParams = createFindParams({
   limit: 50,
   offset: 0,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    email: z.union([z.string(), z.array(z.string())]).optional(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetInvitesParams.array()).optional(),
-    $or: z.lazy(() => AdminGetInvitesParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetInvitesParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetInvitesParamsFields))
 
 export type AdminGetInviteAcceptParamsType = z.infer<
   typeof AdminGetInviteAcceptParams

packages/medusa/src/api/admin/notifications/route.ts

@@ -16,6 +16,7 @@ export const GET = async (
     req.remoteQueryConfig.fields,
     req.remoteQueryConfig.pagination
   )
+
   res.json({
     notifications,
     count: metadata.count,

packages/medusa/src/api/admin/notifications/validators.ts

@@ -1,11 +1,18 @@
 import { z } from "zod"
 import { createFindParams, createSelectParams } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export type AdminGetNotificationParamsType = z.infer<
   typeof AdminGetNotificationParams
 >
 export const AdminGetNotificationParams = createSelectParams()
 
+export const AdminGetNotificationsParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  channel: z.union([z.string(), z.array(z.string())]).optional(),
+})
+
 export type AdminGetNotificationsParamsType = z.infer<
   typeof AdminGetNotificationsParams
 >
@@ -13,12 +20,6 @@ export const AdminGetNotificationsParams = createFindParams({
   limit: 50,
   offset: 0,
   order: "-created_at",
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    channel: z.union([z.string(), z.array(z.string())]).optional(),
-    $and: z.lazy(() => AdminGetNotificationsParams.array()).optional(),
-    $or: z.lazy(() => AdminGetNotificationsParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetNotificationsParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetNotificationsParamsFields))

packages/medusa/src/api/admin/payments/validators.ts

@@ -1,5 +1,8 @@
 import { z } from "zod"
-import { booleanString } from "../../utils/common-validators"
+import {
+  applyAndAndOrOperators,
+  booleanString,
+} from "../../utils/common-validators"
 import {
   createFindParams,
   createOperatorMap,
@@ -9,22 +12,27 @@ import {
 export type AdminGetPaymentParamsType = z.infer<typeof AdminGetPaymentParams>
 export const AdminGetPaymentParams = createSelectParams()
 
+export const AdminGetPaymentsParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  payment_session_id: z.union([z.string(), z.array(z.string())]).optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 export type AdminGetPaymentsParamsType = z.infer<typeof AdminGetPaymentsParams>
 export const AdminGetPaymentsParams = createFindParams({
   limit: 20,
   offset: 0,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    payment_session_id: z.union([z.string(), z.array(z.string())]).optional(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetPaymentsParams.array()).optional(),
-    $or: z.lazy(() => AdminGetPaymentsParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetPaymentsParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetPaymentsParamsFields))
+
+export const AdminGetPaymentProvidersParamsFields = z.object({
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  is_enabled: booleanString().optional(),
+})
 
 export type AdminGetPaymentProvidersParamsType = z.infer<
   typeof AdminGetPaymentProvidersParams
@@ -32,14 +40,9 @@ export type AdminGetPaymentProvidersParamsType = z.infer<
 export const AdminGetPaymentProvidersParams = createFindParams({
   limit: 20,
   offset: 0,
-}).merge(
-  z.object({
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    is_enabled: booleanString().optional(),
-    $and: z.lazy(() => AdminGetPaymentProvidersParams.array()).optional(),
-    $or: z.lazy(() => AdminGetPaymentProvidersParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetPaymentProvidersParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetPaymentProvidersParamsFields))
 
 export type AdminCreatePaymentCaptureType = z.infer<
   typeof AdminCreatePaymentCapture

packages/medusa/src/api/admin/price-lists/validators.ts

@@ -5,23 +5,25 @@ import {
   createOperatorMap,
   createSelectParams,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export const AdminGetPriceListPricesParams = createSelectParams()
+
+export const AdminGetPriceListsParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  starts_at: createOperatorMap().optional(),
+  ends_at: createOperatorMap().optional(),
+  status: z.array(z.nativeEnum(PriceListStatus)).optional(),
+  rules_count: z.array(z.number()).optional(),
+})
+
 export const AdminGetPriceListsParams = createFindParams({
   offset: 0,
   limit: 50,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    starts_at: createOperatorMap().optional(),
-    ends_at: createOperatorMap().optional(),
-    status: z.array(z.nativeEnum(PriceListStatus)).optional(),
-    rules_count: z.array(z.number()).optional(),
-    $and: z.lazy(() => AdminGetPriceListsParams.array()).optional(),
-    $or: z.lazy(() => AdminGetPriceListsParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetPriceListsParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetPriceListsParamsFields))
 
 export const AdminGetPriceListParams = createSelectParams()
 

packages/medusa/src/api/admin/price-preferences/validators.ts

@@ -1,20 +1,22 @@
 import { z } from "zod"
 import { createFindParams, createSelectParams } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export const AdminGetPricePreferenceParams = createSelectParams()
+
+export const AdminGetPricePreferencesParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  attribute: z.union([z.string(), z.array(z.string())]).optional(),
+  value: z.union([z.string(), z.array(z.string())]).optional(),
+})
+
 export const AdminGetPricePreferencesParams = createFindParams({
   offset: 0,
   limit: 300,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    attribute: z.union([z.string(), z.array(z.string())]).optional(),
-    value: z.union([z.string(), z.array(z.string())]).optional(),
-    $and: z.lazy(() => AdminGetPricePreferencesParams.array()).optional(),
-    $or: z.lazy(() => AdminGetPricePreferencesParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetPricePreferencesParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetPricePreferencesParamsFields))
 
 export const AdminCreatePricePreference = z.object({
   attribute: z.string(),

packages/medusa/src/api/admin/product-categories/validators.ts

@@ -1,5 +1,8 @@
 import { z } from "zod"
-import { booleanString } from "../../utils/common-validators"
+import {
+  applyAndAndOrOperators,
+  booleanString,
+} from "../../utils/common-validators"
 import {
   createFindParams,
   createOperatorMap,
@@ -16,30 +19,30 @@ export const AdminProductCategoryParams = createSelectParams().merge(
   })
 )
 
+export const AdminProductCategoriesParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  description: z.union([z.string(), z.array(z.string())]).optional(),
+  handle: z.union([z.string(), z.array(z.string())]).optional(),
+  parent_category_id: z.union([z.string(), z.array(z.string())]).optional(),
+  include_ancestors_tree: booleanString().optional(),
+  include_descendants_tree: booleanString().optional(),
+  is_internal: booleanString().optional(),
+  is_active: booleanString().optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 export type AdminProductCategoriesParamsType = z.infer<
   typeof AdminProductCategoriesParams
 >
 export const AdminProductCategoriesParams = createFindParams({
   offset: 0,
   limit: 50,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    description: z.union([z.string(), z.array(z.string())]).optional(),
-    handle: z.union([z.string(), z.array(z.string())]).optional(),
-    parent_category_id: z.union([z.string(), z.array(z.string())]).optional(),
-    include_ancestors_tree: booleanString().optional(),
-    include_descendants_tree: booleanString().optional(),
-    is_internal: booleanString().optional(),
-    is_active: booleanString().optional(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminProductCategoriesParams.array()).optional(),
-    $or: z.lazy(() => AdminProductCategoriesParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminProductCategoriesParamsFields)
+  .merge(applyAndAndOrOperators(AdminProductCategoriesParamsFields))
 
 export const AdminCreateProductCategory = z
   .object({

packages/medusa/src/api/admin/product-tags/validators.ts

@@ -4,30 +4,31 @@ import {
   createOperatorMap,
   createSelectParams,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export type AdminGetProductTagParamsType = z.infer<
   typeof AdminGetProductTagParams
 >
 export const AdminGetProductTagParams = createSelectParams()
 
+export const AdminGetProductTagsParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  value: z.union([z.string(), z.array(z.string())]).optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 export type AdminGetProductTagsParamsType = z.infer<
   typeof AdminGetProductTagsParams
 >
 export const AdminGetProductTagsParams = createFindParams({
   limit: 20,
   offset: 0,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    value: z.union([z.string(), z.array(z.string())]).optional(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetProductTagsParams.array()).optional(),
-    $or: z.lazy(() => AdminGetProductTagsParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetProductTagsParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetProductTagsParamsFields))
 
 export type AdminCreateProductTagType = z.infer<typeof AdminCreateProductTag>
 export const AdminCreateProductTag = z

packages/medusa/src/api/admin/product-types/validators.ts

@@ -4,32 +4,33 @@ import {
   createOperatorMap,
   createSelectParams,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export type AdminGetProductTypeParamsType = z.infer<
   typeof AdminGetProductTypeParams
 >
 export const AdminGetProductTypeParams = createSelectParams()
 
+export const AdminGetProductTypesParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  value: z.union([z.string(), z.array(z.string())]).optional(),
+  // TODO: To be added in next iteration, when coming from a different module, it should be separated from the direct fields
+  // discount_condition_id: z.string().nullish(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 export type AdminGetProductTypesParamsType = z.infer<
   typeof AdminGetProductTypesParams
 >
 export const AdminGetProductTypesParams = createFindParams({
   limit: 10,
   offset: 0,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    value: z.union([z.string(), z.array(z.string())]).optional(),
-    // TODO: To be added in next iteration
-    // discount_condition_id: z.string().nullish(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetProductTypesParams.array()).optional(),
-    $or: z.lazy(() => AdminGetProductTypesParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetProductTypesParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetProductTypesParamsFields))
 
 export type AdminCreateProductTypeType = z.infer<typeof AdminCreateProductType>
 export const AdminCreateProductType = z

packages/medusa/src/api/admin/product-variants/validators.ts

@@ -1,23 +1,26 @@
 import { z } from "zod"
-import { booleanString } from "../../utils/common-validators"
+import {
+  applyAndAndOrOperators,
+  booleanString,
+} from "../../utils/common-validators"
 import { createFindParams, createOperatorMap } from "../../utils/validators"
 
+export const AdminGetProductVariantsParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  manage_inventory: booleanString().optional(),
+  allow_backorder: booleanString().optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 export type AdminGetProductVariantsParamsType = z.infer<
   typeof AdminGetProductVariantsParams
 >
 export const AdminGetProductVariantsParams = createFindParams({
   offset: 0,
   limit: 50,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    manage_inventory: booleanString().optional(),
-    allow_backorder: booleanString().optional(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetProductVariantsParams.array()).optional(),
-    $or: z.lazy(() => AdminGetProductVariantsParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetProductVariantsParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetProductVariantsParamsFields))

packages/medusa/src/api/admin/products/validators.ts

@@ -2,6 +2,7 @@ import { BatchMethodRequest } from "@medusajs/framework/types"
 import { ProductStatus } from "@medusajs/framework/utils"
 import { z } from "zod"
 import {
+  applyAndAndOrOperators,
   booleanString,
   GetProductsParams,
   transformProductParams,
@@ -19,62 +20,65 @@ export const AdminGetProductParams = createSelectParams()
 export const AdminGetProductVariantParams = createSelectParams()
 export const AdminGetProductOptionParams = createSelectParams()
 
+export const AdminGetProductVariantsParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  manage_inventory: booleanString().optional(),
+  allow_backorder: booleanString().optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 export type AdminGetProductVariantsParamsType = z.infer<
   typeof AdminGetProductVariantsParams
 >
 export const AdminGetProductVariantsParams = createFindParams({
   offset: 0,
   limit: 50,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    manage_inventory: booleanString().optional(),
-    allow_backorder: booleanString().optional(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetProductsParams.array()).optional(),
-    $or: z.lazy(() => AdminGetProductsParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetProductVariantsParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetProductVariantsParamsFields))
+
+export const AdminGetProductsParamsDirectFields = z.object({
+  variants: AdminGetProductVariantsParams.optional(),
+  status: statusEnum.array().optional(),
+})
 
 export type AdminGetProductsParamsType = z.infer<typeof AdminGetProductsParams>
 export const AdminGetProductsParams = createFindParams({
   offset: 0,
   limit: 50,
 })
+  .merge(AdminGetProductsParamsDirectFields)
   .merge(
     z
       .object({
-        variants: AdminGetProductVariantsParams.optional(),
         price_list_id: z.string().array().optional(),
-        status: statusEnum.array().optional(),
-        $and: z.lazy(() => AdminGetProductsParams.array()).optional(),
-        $or: z.lazy(() => AdminGetProductsParams.array()).optional(),
       })
+      .merge(applyAndAndOrOperators(AdminGetProductsParamsDirectFields))
       .merge(GetProductsParams)
   )
   .transform(transformProductParams)
 
+export const AdminGetProductOptionsParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  title: z.string().optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 export type AdminGetProductOptionsParamsType = z.infer<
   typeof AdminGetProductOptionsParams
 >
 export const AdminGetProductOptionsParams = createFindParams({
   offset: 0,
   limit: 50,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    title: z.string().optional(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetProductsParams.array()).optional(),
-    $or: z.lazy(() => AdminGetProductsParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetProductOptionsParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetProductOptionsParamsFields))
 
 export type AdminCreateProductTagType = z.infer<typeof AdminCreateProductTag>
 export const AdminCreateProductTag = z.object({

packages/medusa/src/api/admin/promotions/validators.ts

@@ -13,12 +13,27 @@ import {
   WithAdditionalData,
 } from "../../utils/validators"
 import { CreateCampaign } from "../campaigns/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export type AdminGetPromotionParamsType = z.infer<
   typeof AdminGetPromotionParams
 >
 export const AdminGetPromotionParams = createSelectParams()
 
+export const AdminGetPromotionsParamsFields = z.object({
+  q: z.string().optional(),
+  code: z.union([z.string(), z.array(z.string())]).optional(),
+  campaign_id: z.union([z.string(), z.array(z.string())]).optional(),
+  application_method: z
+    .object({
+      currency_code: z.union([z.string(), z.array(z.string())]).optional(),
+    })
+    .optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 export type AdminGetPromotionsParamsType = z.infer<
   typeof AdminGetPromotionsParams
 >
@@ -26,23 +41,8 @@ export const AdminGetPromotionsParams = createFindParams({
   limit: 50,
   offset: 0,
 })
-  .merge(
-    z.object({
-      q: z.string().optional(),
-      code: z.union([z.string(), z.array(z.string())]).optional(),
-      campaign_id: z.union([z.string(), z.array(z.string())]).optional(),
-      application_method: z
-        .object({
-          currency_code: z.union([z.string(), z.array(z.string())]).optional(),
-        })
-        .optional(),
-      created_at: createOperatorMap().optional(),
-      updated_at: createOperatorMap().optional(),
-      deleted_at: createOperatorMap().optional(),
-      $and: z.lazy(() => AdminGetPromotionsParams.array()).optional(),
-      $or: z.lazy(() => AdminGetPromotionsParams.array()).optional(),
-    })
-  )
+  .merge(AdminGetPromotionsParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetPromotionsParamsFields))
   .strict()
 
 export type AdminGetPromotionRuleParamsType = z.infer<

packages/medusa/src/api/admin/regions/validators.ts

@@ -4,27 +4,28 @@ import {
   createOperatorMap,
   createSelectParams,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export type AdminGetRegionParamsType = z.infer<typeof AdminGetRegionParams>
 export const AdminGetRegionParams = createSelectParams()
 
+export const AdminGetRegionsParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  currency_code: z.union([z.string(), z.array(z.string())]).optional(),
+  name: z.union([z.string(), z.array(z.string())]).optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 export type AdminGetRegionsParamsType = z.infer<typeof AdminGetRegionsParams>
 export const AdminGetRegionsParams = createFindParams({
   limit: 50,
   offset: 0,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    currency_code: z.union([z.string(), z.array(z.string())]).optional(),
-    name: z.union([z.string(), z.array(z.string())]).optional(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetRegionsParams.array()).optional(),
-    $or: z.lazy(() => AdminGetRegionsParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetRegionsParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetRegionsParamsFields))
 
 export type AdminCreateRegionType = z.infer<typeof AdminCreateRegion>
 export const AdminCreateRegion = z

packages/medusa/src/api/admin/return-reasons/validators.ts

@@ -4,6 +4,7 @@ import {
   createOperatorMap,
   createSelectParams,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export const AdminGetReturnReasonsReturnReasonParams =
   createSelectParams().merge(
@@ -25,29 +26,29 @@ export type AdminGetReturnReasonsReturnReasonParamsType = z.infer<
   typeof AdminGetReturnReasonsReturnReasonParams
 >
 
+export const AdminGetReturnReasonsParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  value: z.union([z.string(), z.array(z.string())]).optional(),
+  label: z.union([z.string(), z.array(z.string())]).optional(),
+  description: z.union([z.string(), z.array(z.string())]).optional(),
+  parent_return_reason_id: z
+    .union([z.string(), z.array(z.string())])
+    .optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 /**
  * Parameters used to filter and configure the pagination of the retrieved order.
  */
 export const AdminGetReturnReasonsParams = createFindParams({
   offset: 0,
   limit: 20,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    value: z.union([z.string(), z.array(z.string())]).optional(),
-    label: z.union([z.string(), z.array(z.string())]).optional(),
-    description: z.union([z.string(), z.array(z.string())]).optional(),
-    parent_return_reason_id: z
-      .union([z.string(), z.array(z.string())])
-      .optional(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetReturnReasonsParams.array()).optional(),
-    $or: z.lazy(() => AdminGetReturnReasonsParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetReturnReasonsParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetReturnReasonsParamsFields))
 
 export type AdminGetReturnReasonsParamsType = z.infer<
   typeof AdminGetReturnReasonsParams

packages/medusa/src/api/admin/sales-channels/validators.ts

@@ -1,5 +1,8 @@
 import { z } from "zod"
-import { booleanString } from "../../utils/common-validators"
+import {
+  applyAndAndOrOperators,
+  booleanString,
+} from "../../utils/common-validators"
 import {
   createFindParams,
   createOperatorMap,
@@ -11,28 +14,32 @@ export type AdminGetSalesChannelParamsType = z.infer<
 >
 export const AdminGetSalesChannelParams = createSelectParams()
 
+export const AdminGetSalesChannelsParamsDirectFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  name: z.union([z.string(), z.array(z.string())]).optional(),
+  description: z.string().optional(),
+  is_disabled: booleanString().optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 export type AdminGetSalesChannelsParamsType = z.infer<
   typeof AdminGetSalesChannelsParams
 >
 export const AdminGetSalesChannelsParams = createFindParams({
   limit: 20,
   offset: 0,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    name: z.union([z.string(), z.array(z.string())]).optional(),
-    description: z.string().optional(),
-    is_disabled: booleanString().optional(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    location_id: z.union([z.string(), z.array(z.string())]).optional(),
-    publishable_key_id: z.union([z.string(), z.array(z.string())]).optional(),
-    $and: z.lazy(() => AdminGetSalesChannelsParams.array()).optional(),
-    $or: z.lazy(() => AdminGetSalesChannelsParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetSalesChannelsParamsDirectFields)
+  .merge(applyAndAndOrOperators(AdminGetSalesChannelsParamsDirectFields))
+  .merge(
+    z.object({
+      location_id: z.union([z.string(), z.array(z.string())]).optional(),
+      publishable_key_id: z.union([z.string(), z.array(z.string())]).optional(),
+    })
+  )
 
 export type AdminCreateSalesChannelType = z.infer<
   typeof AdminCreateSalesChannel

packages/medusa/src/api/admin/shipping-profiles/validators.ts

@@ -4,31 +4,32 @@ import {
   createOperatorMap,
   createSelectParams,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export type AdminGetShippingProfileParamsType = z.infer<
   typeof AdminGetShippingProfileParams
 >
 export const AdminGetShippingProfileParams = createSelectParams()
 
+export const AdminGetShippingProfilesParamsFields = z.object({
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  q: z.string().optional(),
+  type: z.string().optional(),
+  name: z.string().optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 export type AdminGetShippingProfilesParamsType = z.infer<
   typeof AdminGetShippingProfilesParams
 >
 export const AdminGetShippingProfilesParams = createFindParams({
   limit: 20,
   offset: 0,
-}).merge(
-  z.object({
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    q: z.string().optional(),
-    type: z.string().optional(),
-    name: z.string().optional(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetShippingProfilesParams.array()).optional(),
-    $or: z.lazy(() => AdminGetShippingProfilesParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetShippingProfilesParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetShippingProfilesParamsFields))
 
 export type AdminCreateShippingProfileType = z.infer<
   typeof AdminCreateShippingProfile

packages/medusa/src/api/admin/stock-locations/validators.ts

@@ -4,32 +4,37 @@ import {
   createOperatorMap,
   createSelectParams,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export type AdminGetStockLocationParamsType = z.infer<
   typeof AdminGetStockLocationParams
 >
 export const AdminGetStockLocationParams = createSelectParams()
 
+export const AdminGetStockLocationsParamsDirectFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  name: z.union([z.string(), z.array(z.string())]).optional(),
+  address_id: z.union([z.string(), z.array(z.string())]).optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 export type AdminGetStockLocationsParamsType = z.infer<
   typeof AdminGetStockLocationsParams
 >
 export const AdminGetStockLocationsParams = createFindParams({
   limit: 20,
   offset: 0,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    name: z.union([z.string(), z.array(z.string())]).optional(),
-    address_id: z.union([z.string(), z.array(z.string())]).optional(),
-    sales_channel_id: z.union([z.string(), z.array(z.string())]).optional(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetStockLocationsParams.array()).optional(),
-    $or: z.lazy(() => AdminGetStockLocationsParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetStockLocationsParamsDirectFields)
+  .merge(applyAndAndOrOperators(AdminGetStockLocationsParamsDirectFields))
+  .merge(
+    z.object({
+      sales_channel_id: z.union([z.string(), z.array(z.string())]).optional(),
+    })
+  )
 
 export type AdminUpsertStockLocationAddressType = z.infer<
   typeof AdminUpsertStockLocationAddress

packages/medusa/src/api/admin/stores/validators.ts

@@ -1,22 +1,23 @@
 import { z } from "zod"
 import { createFindParams, createSelectParams } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export type AdminGetStoreParamsType = z.infer<typeof AdminGetStoreParams>
 export const AdminGetStoreParams = createSelectParams()
 
+export const AdminGetStoresParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  name: z.union([z.string(), z.array(z.string())]).optional(),
+})
+
 export type AdminGetStoresParamsType = z.infer<typeof AdminGetStoresParams>
 export const AdminGetStoresParams = createFindParams({
   limit: 50,
   offset: 0,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    name: z.union([z.string(), z.array(z.string())]).optional(),
-    $and: z.lazy(() => AdminGetStoresParams.array()).optional(),
-    $or: z.lazy(() => AdminGetStoresParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetStoresParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetStoresParamsFields))
 
 export type AdminUpdateStoreType = z.infer<typeof AdminUpdateStore>
 export const AdminUpdateStore = z.object({

packages/medusa/src/api/admin/tax-rates/validators.ts

@@ -4,28 +4,29 @@ import {
   createOperatorMap,
   createSelectParams,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export type AdminGetTaxRateParamsType = z.infer<typeof AdminGetTaxRateParams>
 export const AdminGetTaxRateParams = createSelectParams()
 
+export const AdminGetTaxRatesParamsFields = z.object({
+  q: z.string().optional(),
+  tax_region_id: z
+    .union([z.string(), z.array(z.string()), createOperatorMap()])
+    .optional(),
+  is_default: z.union([z.literal("true"), z.literal("false")]).optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 export type AdminGetTaxRatesParamsType = z.infer<typeof AdminGetTaxRatesParams>
 export const AdminGetTaxRatesParams = createFindParams({
   limit: 20,
   offset: 0,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    tax_region_id: z
-      .union([z.string(), z.array(z.string()), createOperatorMap()])
-      .optional(),
-    is_default: z.union([z.literal("true"), z.literal("false")]).optional(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetTaxRatesParams.array()).optional(),
-    $or: z.lazy(() => AdminGetTaxRatesParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetTaxRatesParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetTaxRatesParamsFields))
 
 export type AdminCreateTaxRateRuleType = z.infer<typeof AdminCreateTaxRateRule>
 export const AdminCreateTaxRateRule = z.object({

packages/medusa/src/api/admin/tax-regions/validators.ts

@@ -4,39 +4,40 @@ import {
   createOperatorMap,
   createSelectParams,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export type AdminGetTaxRegionParamsType = z.infer<
   typeof AdminGetTaxRegionParams
 >
 export const AdminGetTaxRegionParams = createSelectParams()
 
+export const AdminGetTaxRegionsParamsFields = z.object({
+  q: z.string().optional(),
+  id: z.union([z.string(), z.array(z.string())]).optional(),
+  country_code: z
+    .union([z.string(), z.array(z.string()), createOperatorMap()])
+    .optional(),
+  province_code: z
+    .union([z.string(), z.array(z.string()), createOperatorMap()])
+    .optional(),
+  parent_id: z
+    .union([z.string(), z.array(z.string()), createOperatorMap()])
+    .optional(),
+  created_by: z.union([z.string(), z.array(z.string())]).optional(),
+  created_at: createOperatorMap().optional(),
+  updated_at: createOperatorMap().optional(),
+  deleted_at: createOperatorMap().optional(),
+})
+
 export type AdminGetTaxRegionsParamsType = z.infer<
   typeof AdminGetTaxRegionsParams
 >
 export const AdminGetTaxRegionsParams = createFindParams({
   limit: 20,
   offset: 0,
-}).merge(
-  z.object({
-    q: z.string().optional(),
-    id: z.union([z.string(), z.array(z.string())]).optional(),
-    country_code: z
-      .union([z.string(), z.array(z.string()), createOperatorMap()])
-      .optional(),
-    province_code: z
-      .union([z.string(), z.array(z.string()), createOperatorMap()])
-      .optional(),
-    parent_id: z
-      .union([z.string(), z.array(z.string()), createOperatorMap()])
-      .optional(),
-    created_by: z.union([z.string(), z.array(z.string())]).optional(),
-    created_at: createOperatorMap().optional(),
-    updated_at: createOperatorMap().optional(),
-    deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetTaxRegionsParams.array()).optional(),
-    $or: z.lazy(() => AdminGetTaxRegionsParams.array()).optional(),
-  })
-)
+})
+  .merge(AdminGetTaxRegionsParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetTaxRegionsParamsFields))
 
 export type AdminCreateTaxRegionType = z.infer<typeof AdminCreateTaxRegion>
 export const AdminCreateTaxRegion = z.object({