feat: Add support for search to all endpoints (#7149)

* feat: Add search capability to api keys

* feat: Add support for searching to currency and customer endpoints

* fix: Clean up product search filters

* feat: Add search support to regions

* feat: Add search support to sales channels

* feat: Add search support to store module

* feat: Add search support to user module

* fix: Clean up inventory search

* feat: Add search support for payments

* fix: Add searchable attributes to stock location models

* feat: Add search support to tax

* feat: Add search support to promotions

* feat: Add search support for pricing, filtering cleanup

* fix: Further cleanups around search

integration-tests/modules/__tests__/currency/admin/currency.spec.ts

@@ -53,6 +53,18 @@ medusaIntegrationTestRunner({
           expect.objectContaining({ code: "zwl", name: "Zimbabwean Dollar" })
         )
       })
+
+      it("should allow for searching of currencies", async () => {
+        const listResp = await api.get(
+          "/admin/currencies?q=zimbabwean",
+          adminHeaders
+        )
+
+        expect(listResp.data.currencies).toHaveLength(1)
+        expect(listResp.data.currencies[0]).toEqual(
+          expect.objectContaining({ code: "zwl", name: "Zimbabwean Dollar" })
+        )
+      })
     })
   },
 })

integration-tests/modules/__tests__/customer-group/admin/list-customer-groups.spec.ts

@@ -44,6 +44,29 @@ medusaIntegrationTestRunner({
           }),
         ])
       })
+
+      it("should support searching of customer groups", async () => {
+        await customerModuleService.createCustomerGroup([
+          {
+            name: "First group",
+          },
+          { name: "Second group" },
+        ])
+
+        const response = await api.get(
+          `/admin/customer-groups?q=fir`,
+          adminHeaders
+        )
+
+        expect(response.status).toEqual(200)
+        expect(response.data.customer_groups).toHaveLength(1)
+        expect(response.data.customer_groups[0]).toEqual(
+          expect.objectContaining({
+            id: expect.any(String),
+            name: "First group",
+          })
+        )
+      })
     })
   },
 })

integration-tests/modules/__tests__/customer/admin/list-customer-addresses.ts

@@ -92,6 +92,53 @@ medusaIntegrationTestRunner({
           ])
         )
       })
+
+      it("should support searching through the addresses", async () => {
+        const [customer] = await customerModuleService.create([
+          {
+            first_name: "Test",
+            last_name: "Test",
+            email: "test@me.com",
+            addresses: [
+              {
+                first_name: "John",
+                last_name: "Doe",
+                address_1: "Huntingdon 123",
+              },
+              {
+                first_name: "Jane",
+                last_name: "Doe",
+                address_1: "Horseshoe 555",
+              },
+              {
+                first_name: "Jack",
+                last_name: "Doe",
+                address_1: "Hawkins 12",
+              },
+            ],
+          },
+        ])
+
+        const response = await api.get(
+          `/admin/customers/${customer.id}/addresses?q=12`,
+          adminHeaders
+        )
+
+        expect(response.status).toEqual(200)
+        expect(response.data.addresses).toHaveLength(2)
+        expect(response.data.addresses).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({
+              id: expect.any(String),
+              address_1: "Huntingdon 123",
+            }),
+            expect.objectContaining({
+              id: expect.any(String),
+              address_1: "Hawkins 12",
+            }),
+          ])
+        )
+      })
     })
   },
 })

integration-tests/modules/__tests__/customer/admin/list-customers.spec.ts

@@ -141,6 +141,43 @@ medusaIntegrationTestRunner({
           })
         )
       })
+
+      it("should support searching of customers", async () => {
+        await customerModuleService.create([
+          {
+            first_name: "Jane",
+            last_name: "Doe",
+            email: "jane@me.com",
+          },
+          {
+            first_name: "John",
+            last_name: "Doe",
+            email: "john@me.com",
+          },
+          {
+            first_name: "LeBron",
+            last_name: "James",
+            email: "lebron@me.com",
+          },
+        ])
+
+        const response = await api.get(`/admin/customers?q=do`, adminHeaders)
+
+        expect(response.status).toEqual(200)
+        expect(response.data.customers).toHaveLength(2)
+        expect(response.data.customers).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({
+              first_name: "Jane",
+              last_name: "Doe",
+            }),
+            expect.objectContaining({
+              first_name: "John",
+              last_name: "Doe",
+            }),
+          ])
+        )
+      })
     })
   },
 })

integration-tests/modules/__tests__/price-lists/admin/price-lists.spec.ts

@@ -162,6 +162,71 @@ medusaIntegrationTestRunner({
             },
           ])
         })
+
+        it("should support searching of price lists", async () => {
+          const priceSet = await createVariantPriceSet({
+            container: appContainer,
+            variantId: variant.id,
+            prices: [],
+          })
+
+          await pricingModule.createPriceLists([
+            {
+              title: "first price list",
+              description: "test price",
+              ends_at: new Date(),
+              starts_at: new Date(),
+              status: PriceListStatus.ACTIVE,
+              type: PriceListType.OVERRIDE,
+              prices: [
+                {
+                  amount: 5000,
+                  currency_code: "usd",
+                  price_set_id: priceSet.id,
+                  rules: {
+                    region_id: region.id,
+                  },
+                },
+              ],
+              rules: {
+                customer_group_id: [customerGroup.id],
+              },
+            },
+            {
+              title: "second price list",
+              description: "second test",
+              ends_at: new Date(),
+              starts_at: new Date(),
+              status: PriceListStatus.ACTIVE,
+              type: PriceListType.OVERRIDE,
+              prices: [
+                {
+                  amount: 5000,
+                  currency_code: "usd",
+                  price_set_id: priceSet.id,
+                  rules: {
+                    region_id: region.id,
+                  },
+                },
+              ],
+              rules: {
+                customer_group_id: [customerGroup.id],
+              },
+            },
+          ])
+
+          let response = await api.get(
+            `/admin/price-lists?q=second`,
+            adminHeaders
+          )
+
+          expect(response.status).toEqual(200)
+          expect(response.data.price_lists).toEqual([
+            expect.objectContaining({
+              title: "second price list",
+            }),
+          ])
+        })
       })
 
       describe("GET /admin/price-lists/:id", () => {

integration-tests/modules/__tests__/promotion/admin/list-campaigns.spec.ts

@@ -130,6 +130,20 @@ medusaIntegrationTestRunner({
         )
       })
 
+      it("should support search on campaigns", async () => {
+        const response = await api.get(
+          `/admin/campaigns?q=ign%202`,
+          adminHeaders
+        )
+
+        expect(response.status).toEqual(200)
+        expect(response.data.campaigns).toEqual([
+          expect.objectContaining({
+            name: "campaign 2",
+          }),
+        ])
+      })
+
       it("should get all campaigns and its count filtered", async () => {
         const response = await api.get(
           `/admin/campaigns?fields=name,created_at,budget.id`,

integration-tests/modules/__tests__/promotion/admin/list-promotions.spec.ts

@@ -67,6 +67,38 @@ medusaIntegrationTestRunner({
         ])
       })
 
+      it("should support search of promotions", async () => {
+        await promotionModuleService.create([
+          {
+            code: "first",
+            type: PromotionType.STANDARD,
+            application_method: {
+              type: "fixed",
+              target_type: "order",
+              value: 100,
+            },
+          },
+          {
+            code: "second",
+            type: PromotionType.STANDARD,
+            application_method: {
+              type: "fixed",
+              target_type: "order",
+              value: 100,
+            },
+          },
+        ])
+
+        const response = await api.get(`/admin/promotions?q=fir`, adminHeaders)
+
+        expect(response.status).toEqual(200)
+        expect(response.data.promotions).toEqual([
+          expect.objectContaining({
+            code: "first",
+          }),
+        ])
+      })
+
       it("should get all promotions and its count filtered", async () => {
         await promotionModuleService.create([
           {

integration-tests/modules/__tests__/regions/admin/regions.spec.ts

@@ -343,6 +343,31 @@ medusaIntegrationTestRunner({
         ])
       })
 
+      it("should support searching of regions", async () => {
+        await service.create([
+          {
+            name: "APAC",
+            currency_code: "usd",
+            countries: ["jp"],
+          },
+          {
+            name: "Europe",
+            currency_code: "eur",
+            countries: ["de"],
+          },
+        ])
+
+        const response = await api.get(`/admin/regions?q=eu`, adminHeaders)
+
+        expect(response.status).toEqual(200)
+        expect(response.data.regions).toEqual([
+          expect.objectContaining({
+            name: "Europe",
+            currency_code: "eur",
+          }),
+        ])
+      })
+
       it("should get a region", async () => {
         const [region] = await service.create([
           {

integration-tests/modules/__tests__/tax/admin/tax.spec.ts

@@ -64,6 +64,33 @@ medusaIntegrationTestRunner({
         })
       })
 
+      it("can search through tax rates", async () => {
+        const region = await service.createTaxRegions({
+          country_code: "us",
+        })
+
+        await service.create({
+          tax_region_id: region.id,
+          code: "low",
+          rate: 2.5,
+          name: "low rate",
+        })
+
+        await service.create({
+          tax_region_id: region.id,
+          code: "high",
+          rate: 5,
+          name: "high rate",
+        })
+
+        const response = await api.get(`/admin/tax-rates?q=high`, adminHeaders)
+
+        expect(response.status).toEqual(200)
+        expect(response.data.tax_rates).toEqual(
+          expect.arrayContaining([expect.objectContaining({ code: "high" })])
+        )
+      })
+
       it("can create a tax region with rates and rules", async () => {
         const regionRes = await api.post(
           `/admin/tax-regions`,
@@ -402,6 +429,31 @@ medusaIntegrationTestRunner({
         })
       })
 
+      it("can search through tax regions", async () => {
+        await service.createTaxRegions([
+          {
+            country_code: "us",
+            province_code: "texas",
+          },
+          {
+            country_code: "us",
+            province_code: "florida",
+          },
+        ])
+
+        const response = await api.get(`/admin/tax-regions?q=ida`, adminHeaders)
+
+        expect(response.status).toEqual(200)
+        expect(response.data.tax_regions).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({
+              country_code: "us",
+              province_code: "florida",
+            }),
+          ])
+        )
+      })
+
       it("can create a tax region and delete it", async () => {
         const regionRes = await api.post(
           `/admin/tax-regions`,