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,15 +5,11 @@ import {
   createOperatorMap,
   createSelectParams,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export const AdminGetApiKeyParams = createSelectParams()
 
-export type AdminGetApiKeysParamsType = z.infer<typeof AdminGetApiKeysParams>
+export const AdminGetApiKeysParamsFields = z.object({
-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(),
@@ -23,10 +19,15 @@ export const AdminGetApiKeysParams = createFindParams({
   updated_at: createOperatorMap().optional(),
   deleted_at: createOperatorMap().optional(),
   revoked_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetApiKeysParams.array()).optional(),
+})
-    $or: z.lazy(() => AdminGetApiKeysParams.array()).optional(),
+
-  })
+export type AdminGetApiKeysParamsType = z.infer<typeof AdminGetApiKeysParams>
-)
+export const AdminGetApiKeysParams = createFindParams({
+  offset: 0,
+  limit: 20,
+})
+  .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(
+  .merge(AdminGetCampaignsParamsFields)
-    z.object({
+  .merge(applyAndAndOrOperators(AdminGetCampaignsParamsFields).strict())
-      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()
 
 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({
+  .merge(AdminGetCollectionsParamsFields)
-    q: z.string().optional(),
+  .merge(applyAndAndOrOperators(AdminGetCollectionsParamsFields))
-    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(),
-  })
-)
 
 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({
+  .merge(AdminGetCurrenciesParamsFields)
-    q: z.string().optional(),
+  .merge(applyAndAndOrOperators(AdminGetCurrenciesParamsFields))
-    code: z.union([z.string(), z.array(z.string())]).optional(),
-    $and: z.lazy(() => AdminGetCurrenciesParams.array()).optional(),
-    $or: z.lazy(() => AdminGetCurrenciesParams.array()).optional(),
-  })
-)

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,14 +31,7 @@ export const AdminCustomerInGroupFilters = z.object({
   deleted_at: createOperatorMap().optional(),
 })
 
-export type AdminGetCustomerGroupsParamsType = z.infer<
+export const AdminGetCustomerGroupsParamsFields = z.object({
-  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(),
@@ -48,10 +42,17 @@ export const AdminGetCustomerGroupsParams = createFindParams({
   created_at: createOperatorMap().optional(),
   updated_at: createOperatorMap().optional(),
   deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetCustomerGroupsParams.array()).optional(),
+})
-    $or: z.lazy(() => AdminGetCustomerGroupsParams.array()).optional(),
+
-  })
+export type AdminGetCustomerGroupsParamsType = z.infer<
-)
+  typeof AdminGetCustomerGroupsParams
+>
+export const AdminGetCustomerGroupsParams = createFindParams({
+  limit: 50,
+  offset: 0,
+})
+  .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,11 +20,7 @@ export const AdminCustomerGroupInCustomerParams = z.object({
   deleted_at: createOperatorMap().optional(),
 })
 
-export const AdminCustomersParams = createFindParams({
+export const AdminCustomersParamsFields = z.object({
-  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(),
@@ -40,10 +39,14 @@ export const AdminCustomersParams = createFindParams({
   created_at: createOperatorMap().optional(),
   updated_at: createOperatorMap().optional(),
   deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminCustomersParams.array()).optional(),
+})
-    $or: z.lazy(() => AdminCustomersParams.array()).optional(),
+
-  })
+export const AdminCustomersParams = createFindParams({
-)
+  limit: 50,
+  offset: 0,
+})
+  .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({
+  .merge(AdminGetOrdersParamsFields)
-    id: z.union([z.string(), z.array(z.string())]).optional(),
+  .merge(applyAndAndOrOperators(AdminGetOrdersParamsFields))
-    $and: z.lazy(() => AdminGetOrdersParams.array()).optional(),
-    $or: z.lazy(() => AdminGetOrdersParams.array()).optional(),
-  })
-)
 
 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,15 +14,7 @@ export type AdminGetInventoryItemParamsType = z.infer<
 >
 export const AdminGetInventoryItemParams = createSelectParams()
 
-export type AdminGetInventoryItemsParamsType = z.infer<
+export const AdminGetInventoryItemsParamsFields = z.object({
-  typeof AdminGetInventoryItemsParams
->
-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(),
@@ -37,10 +32,17 @@ export const AdminGetInventoryItemsParams = createFindParams({
       location_id: z.union([z.string(), z.array(z.string())]).optional(),
     })
     .optional(),
-      $and: z.lazy(() => AdminGetInventoryItemsParams.array()).optional(),
+})
-      $or: z.lazy(() => AdminGetInventoryItemsParams.array()).optional(),
+
-    })
+export type AdminGetInventoryItemsParamsType = z.infer<
-  )
+  typeof AdminGetInventoryItemsParams
+>
+export const AdminGetInventoryItemsParams = createFindParams({
+  limit: 20,
+  offset: 0,
+})
+  .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({
+  .merge(AdminGetInventoryLocationLevelsParamsFields)
-    location_id: z.union([z.string(), z.array(z.string())]).optional(),
+  .merge(applyAndAndOrOperators(AdminGetInventoryLocationLevelsParamsFields))
-    $and: z
-      .lazy(() => AdminGetInventoryLocationLevelsParams.array())
-      .optional(),
-    $or: z.lazy(() => AdminGetInventoryLocationLevelsParams.array()).optional(),
-  })
-)
 
 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 type AdminGetInvitesParamsType = z.infer<typeof AdminGetInvitesParams>
+export const AdminGetInvitesParamsFields = z.object({
-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(),
+
-  })
+export type AdminGetInvitesParamsType = z.infer<typeof AdminGetInvitesParams>
-)
+export const AdminGetInvitesParams = createFindParams({
+  limit: 50,
+  offset: 0,
+})
+  .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({
+  .merge(AdminGetNotificationsParamsFields)
-    q: z.string().optional(),
+  .merge(applyAndAndOrOperators(AdminGetNotificationsParamsFields))
-    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(),
-  })
-)

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 type AdminGetPaymentsParamsType = z.infer<typeof AdminGetPaymentsParams>
+export const AdminGetPaymentsParamsFields = z.object({
-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(),
+
-  })
+export type AdminGetPaymentsParamsType = z.infer<typeof AdminGetPaymentsParams>
-)
+export const AdminGetPaymentsParams = createFindParams({
+  limit: 20,
+  offset: 0,
+})
+  .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({
+  .merge(AdminGetPaymentProvidersParamsFields)
-    id: z.union([z.string(), z.array(z.string())]).optional(),
+  .merge(applyAndAndOrOperators(AdminGetPaymentProvidersParamsFields))
-    is_enabled: booleanString().optional(),
-    $and: z.lazy(() => AdminGetPaymentProvidersParams.array()).optional(),
-    $or: z.lazy(() => AdminGetPaymentProvidersParams.array()).optional(),
-  })
-)
 
 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 AdminGetPriceListsParams = createFindParams({
+
-  offset: 0,
+export const AdminGetPriceListsParamsFields = z.object({
-  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(),
+
-  })
+export const AdminGetPriceListsParams = createFindParams({
-)
+  offset: 0,
+  limit: 50,
+})
+  .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 AdminGetPricePreferencesParams = createFindParams({
+
-  offset: 0,
+export const AdminGetPricePreferencesParamsFields = z.object({
-  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(),
+
-  })
+export const AdminGetPricePreferencesParams = createFindParams({
-)
+  offset: 0,
+  limit: 300,
+})
+  .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,14 +19,7 @@ export const AdminProductCategoryParams = createSelectParams().merge(
   })
 )
 
-export type AdminProductCategoriesParamsType = z.infer<
+export const AdminProductCategoriesParamsFields = z.object({
-  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(),
@@ -36,10 +32,17 @@ export const AdminProductCategoriesParams = createFindParams({
   created_at: createOperatorMap().optional(),
   updated_at: createOperatorMap().optional(),
   deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminProductCategoriesParams.array()).optional(),
+})
-    $or: z.lazy(() => AdminProductCategoriesParams.array()).optional(),
+
-  })
+export type AdminProductCategoriesParamsType = z.infer<
-)
+  typeof AdminProductCategoriesParams
+>
+export const AdminProductCategoriesParams = createFindParams({
+  offset: 0,
+  limit: 50,
+})
+  .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({
+  .merge(AdminGetProductTagsParamsFields)
-    q: z.string().optional(),
+  .merge(applyAndAndOrOperators(AdminGetProductTagsParamsFields))
-    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(),
-  })
-)
 
 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({
+  .merge(AdminGetProductTypesParamsFields)
-    q: z.string().optional(),
+  .merge(applyAndAndOrOperators(AdminGetProductTypesParamsFields))
-    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(),
-  })
-)
 
 export type AdminCreateProductTypeType = z.infer<typeof AdminCreateProductType>
 export const AdminCreateProductType = z

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

@@ -1,15 +1,11 @@
 import { z } from "zod"
-import { booleanString } from "../../utils/common-validators"
+import {
+  applyAndAndOrOperators,
+  booleanString,
+} from "../../utils/common-validators"
 import { createFindParams, createOperatorMap } from "../../utils/validators"
 
-export type AdminGetProductVariantsParamsType = z.infer<
+export const AdminGetProductVariantsParamsFields = z.object({
-  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(),
@@ -17,7 +13,14 @@ export const AdminGetProductVariantsParams = createFindParams({
   created_at: createOperatorMap().optional(),
   updated_at: createOperatorMap().optional(),
   deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetProductVariantsParams.array()).optional(),
+})
-    $or: z.lazy(() => AdminGetProductVariantsParams.array()).optional(),
+
-  })
+export type AdminGetProductVariantsParamsType = z.infer<
-)
+  typeof AdminGetProductVariantsParams
+>
+export const AdminGetProductVariantsParams = createFindParams({
+  offset: 0,
+  limit: 50,
+})
+  .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,14 +20,7 @@ export const AdminGetProductParams = createSelectParams()
 export const AdminGetProductVariantParams = createSelectParams()
 export const AdminGetProductOptionParams = createSelectParams()
 
-export type AdminGetProductVariantsParamsType = z.infer<
+export const AdminGetProductVariantsParamsFields = z.object({
-  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(),
@@ -34,47 +28,57 @@ export const AdminGetProductVariantsParams = createFindParams({
   created_at: createOperatorMap().optional(),
   updated_at: createOperatorMap().optional(),
   deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetProductsParams.array()).optional(),
+})
-    $or: z.lazy(() => AdminGetProductsParams.array()).optional(),
+
-  })
+export type AdminGetProductVariantsParamsType = z.infer<
-)
+  typeof AdminGetProductVariantsParams
+>
+export const AdminGetProductVariantsParams = createFindParams({
+  offset: 0,
+  limit: 50,
+})
+  .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({
+  .merge(AdminGetProductOptionsParamsFields)
-    q: z.string().optional(),
+  .merge(applyAndAndOrOperators(AdminGetProductOptionsParamsFields))
-    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(),
-  })
-)
 
 export type AdminCreateProductTagType = z.infer<typeof AdminCreateProductTag>
 export const AdminCreateProductTag = z.object({

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

@@ -13,21 +13,14 @@ 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 type AdminGetPromotionsParamsType = z.infer<
+export const AdminGetPromotionsParamsFields = z.object({
-  typeof AdminGetPromotionsParams
->
-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(),
@@ -39,10 +32,17 @@ export const AdminGetPromotionsParams = createFindParams({
   created_at: createOperatorMap().optional(),
   updated_at: createOperatorMap().optional(),
   deleted_at: createOperatorMap().optional(),
-      $and: z.lazy(() => AdminGetPromotionsParams.array()).optional(),
+})
-      $or: z.lazy(() => AdminGetPromotionsParams.array()).optional(),
+
-    })
+export type AdminGetPromotionsParamsType = z.infer<
-  )
+  typeof AdminGetPromotionsParams
+>
+export const AdminGetPromotionsParams = createFindParams({
+  limit: 50,
+  offset: 0,
+})
+  .merge(AdminGetPromotionsParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetPromotionsParamsFields))
   .strict()
 
 export type AdminGetPromotionRuleParamsType = z.infer<

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

@@ -4,16 +4,12 @@ import {
   createOperatorMap,
   createSelectParams,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export type AdminGetRegionParamsType = z.infer<typeof AdminGetRegionParams>
 export const AdminGetRegionParams = createSelectParams()
 
-export type AdminGetRegionsParamsType = z.infer<typeof AdminGetRegionsParams>
+export const AdminGetRegionsParamsFields = z.object({
-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(),
@@ -21,10 +17,15 @@ export const AdminGetRegionsParams = createFindParams({
   created_at: createOperatorMap().optional(),
   updated_at: createOperatorMap().optional(),
   deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetRegionsParams.array()).optional(),
+})
-    $or: z.lazy(() => AdminGetRegionsParams.array()).optional(),
+
-  })
+export type AdminGetRegionsParamsType = z.infer<typeof AdminGetRegionsParams>
-)
+export const AdminGetRegionsParams = createFindParams({
+  limit: 50,
+  offset: 0,
+})
+  .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,14 +26,7 @@ export type AdminGetReturnReasonsReturnReasonParamsType = z.infer<
   typeof AdminGetReturnReasonsReturnReasonParams
 >
 
-/**
+export const AdminGetReturnReasonsParamsFields = z.object({
- * 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(),
@@ -44,10 +38,17 @@ export const AdminGetReturnReasonsParams = createFindParams({
   created_at: createOperatorMap().optional(),
   updated_at: createOperatorMap().optional(),
   deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetReturnReasonsParams.array()).optional(),
+})
-    $or: z.lazy(() => AdminGetReturnReasonsParams.array()).optional(),
+
-  })
+/**
-)
+ * Parameters used to filter and configure the pagination of the retrieved order.
+ */
+export const AdminGetReturnReasonsParams = createFindParams({
+  offset: 0,
+  limit: 20,
+})
+  .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,14 +14,7 @@ export type AdminGetSalesChannelParamsType = z.infer<
 >
 export const AdminGetSalesChannelParams = createSelectParams()
 
-export type AdminGetSalesChannelsParamsType = z.infer<
+export const AdminGetSalesChannelsParamsDirectFields = z.object({
-  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(),
@@ -27,12 +23,23 @@ export const AdminGetSalesChannelsParams = createFindParams({
   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(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(),
-    $and: z.lazy(() => AdminGetSalesChannelsParams.array()).optional(),
-    $or: z.lazy(() => AdminGetSalesChannelsParams.array()).optional(),
     })
-)
+  )
 
 export type AdminCreateSalesChannelType = z.infer<
   typeof AdminCreateSalesChannel

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

@@ -4,20 +4,14 @@ import {
   createOperatorMap,
   createSelectParams,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export type AdminGetShippingProfileParamsType = z.infer<
   typeof AdminGetShippingProfileParams
 >
 export const AdminGetShippingProfileParams = createSelectParams()
 
-export type AdminGetShippingProfilesParamsType = z.infer<
+export const AdminGetShippingProfilesParamsFields = z.object({
-  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(),
@@ -25,10 +19,17 @@ export const AdminGetShippingProfilesParams = createFindParams({
   created_at: createOperatorMap().optional(),
   updated_at: createOperatorMap().optional(),
   deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetShippingProfilesParams.array()).optional(),
+})
-    $or: z.lazy(() => AdminGetShippingProfilesParams.array()).optional(),
+
-  })
+export type AdminGetShippingProfilesParamsType = z.infer<
-)
+  typeof AdminGetShippingProfilesParams
+>
+export const AdminGetShippingProfilesParams = createFindParams({
+  limit: 20,
+  offset: 0,
+})
+  .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(
+})
+  .merge(AdminGetStockLocationsParamsDirectFields)
+  .merge(applyAndAndOrOperators(AdminGetStockLocationsParamsDirectFields))
+  .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(),
     })
-)
+  )
 
 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({
+  .merge(AdminGetStoresParamsFields)
-    q: z.string().optional(),
+  .merge(applyAndAndOrOperators(AdminGetStoresParamsFields))
-    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(),
-  })
-)
 
 export type AdminUpdateStoreType = z.infer<typeof AdminUpdateStore>
 export const AdminUpdateStore = z.object({

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

@@ -4,16 +4,12 @@ import {
   createOperatorMap,
   createSelectParams,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export type AdminGetTaxRateParamsType = z.infer<typeof AdminGetTaxRateParams>
 export const AdminGetTaxRateParams = createSelectParams()
 
-export type AdminGetTaxRatesParamsType = z.infer<typeof AdminGetTaxRatesParams>
+export const AdminGetTaxRatesParamsFields = z.object({
-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()])
@@ -22,10 +18,15 @@ export const AdminGetTaxRatesParams = createFindParams({
   created_at: createOperatorMap().optional(),
   updated_at: createOperatorMap().optional(),
   deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetTaxRatesParams.array()).optional(),
+})
-    $or: z.lazy(() => AdminGetTaxRatesParams.array()).optional(),
+
-  })
+export type AdminGetTaxRatesParamsType = z.infer<typeof AdminGetTaxRatesParams>
-)
+export const AdminGetTaxRatesParams = createFindParams({
+  limit: 20,
+  offset: 0,
+})
+  .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,20 +4,14 @@ import {
   createOperatorMap,
   createSelectParams,
 } from "../../utils/validators"
+import { applyAndAndOrOperators } from "../../utils/common-validators"
 
 export type AdminGetTaxRegionParamsType = z.infer<
   typeof AdminGetTaxRegionParams
 >
 export const AdminGetTaxRegionParams = createSelectParams()
 
-export type AdminGetTaxRegionsParamsType = z.infer<
+export const AdminGetTaxRegionsParamsFields = z.object({
-  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
@@ -33,10 +27,17 @@ export const AdminGetTaxRegionsParams = createFindParams({
   created_at: createOperatorMap().optional(),
   updated_at: createOperatorMap().optional(),
   deleted_at: createOperatorMap().optional(),
-    $and: z.lazy(() => AdminGetTaxRegionsParams.array()).optional(),
+})
-    $or: z.lazy(() => AdminGetTaxRegionsParams.array()).optional(),
+
-  })
+export type AdminGetTaxRegionsParamsType = z.infer<
-)
+  typeof AdminGetTaxRegionsParams
+>
+export const AdminGetTaxRegionsParams = createFindParams({
+  limit: 20,
+  offset: 0,
+})
+  .merge(AdminGetTaxRegionsParamsFields)
+  .merge(applyAndAndOrOperators(AdminGetTaxRegionsParamsFields))
 
 export type AdminCreateTaxRegionType = z.infer<typeof AdminCreateTaxRegion>
 export const AdminCreateTaxRegion = z.object({