fix(api-elasticsearch): contains query with slash (#3515)

webiny · Sep 14, 2023 · ec99365 · ec99365
1 parent 031884b
commit ec99365
Show file tree

Hide file tree

Showing 5 changed files with 302 additions and 14 deletions.
diff --git a/packages/api-elasticsearch/src/normalize.ts b/packages/api-elasticsearch/src/normalize.ts
@@ -27,7 +27,7 @@ const specialCharacters = [
     "\\*",
     "\\?",
     "\\:",
-    "\\/",
+    `\/`,
     "\\#"
 ];
 
@@ -43,3 +43,26 @@ export const normalizeValue = (value: string) => {
 
     return result || "";
 };
+
+export const normalizeValueWithAsterisk = (initial: string) => {
+    const value = normalizeValue(initial);
+    const results = value.split(" ");
+
+    let result = value;
+    /**
+     * If there is a / in the first word, do not put asterisk in front of it.
+     */
+    const firstWord = results[0];
+    if (firstWord && firstWord.includes("/") === false) {
+        result = `*${result}`;
+    }
+    /**
+     * If there is a / in the last word, do not put asterisk at the end of it.
+     */
+    const lastWord = results[results.length - 1];
+    if (lastWord && lastWord.includes("/") === false) {
+        result = `${result}*`;
+    }
+
+    return result;
+};
diff --git a/packages/api-elasticsearch/src/plugins/operator/contains.ts b/packages/api-elasticsearch/src/plugins/operator/contains.ts
@@ -1,5 +1,5 @@
 import { ElasticsearchQueryBuilderOperatorPlugin } from "~/plugins/definition/ElasticsearchQueryBuilderOperatorPlugin";
-import { normalizeValue } from "~/normalize";
+import { normalizeValueWithAsterisk } from "~/normalize";
 import { ElasticsearchBoolQueryConfig, ElasticsearchQueryBuilderArgsPlugin } from "~/types";
 
 export class ElasticsearchQueryBuilderOperatorContainsPlugin extends ElasticsearchQueryBuilderOperatorPlugin {
@@ -18,7 +18,7 @@ export class ElasticsearchQueryBuilderOperatorContainsPlugin extends Elasticsear
             query_string: {
                 allow_leading_wildcard: true,
                 fields: [basePath],
-                query: `*${normalizeValue(value)}*`,
+                query: normalizeValueWithAsterisk(value),
                 default_operator: "and"
             }
         });

diff --git a/packages/api-elasticsearch/src/plugins/operator/japanese/contains.ts b/packages/api-elasticsearch/src/plugins/operator/japanese/contains.ts
@@ -1,5 +1,5 @@
 import { ElasticsearchQueryBuilderOperatorPlugin } from "~/plugins/definition/ElasticsearchQueryBuilderOperatorPlugin";
-import { normalizeValue } from "~/normalize";
+import { normalizeValueWithAsterisk } from "~/normalize";
 import { ElasticsearchBoolQueryConfig, ElasticsearchQueryBuilderArgsPlugin } from "~/types";
 
 export class ElasticsearchQueryBuilderJapaneseOperatorContainsPlugin extends ElasticsearchQueryBuilderOperatorPlugin {
@@ -22,17 +22,17 @@ export class ElasticsearchQueryBuilderJapaneseOperatorContainsPlugin extends Ela
     ): void {
         const { value: initialValue, basePath } = params;
 
-        const value = normalizeValue(initialValue);
+        const value = normalizeValueWithAsterisk(initialValue);
         query.must.push({
             multi_match: {
-                query: `*${value}*`,
+                query: value,
                 type: "phrase",
                 fields: [`${basePath}.ngram`]
             }
         });
         query.should.push({
             multi_match: {
-                query: `*${value}*`,
+                query: value,
                 type: "phrase",
                 fields: [`${basePath}`]
             }

diff --git a/packages/api-elasticsearch/src/plugins/operator/notContains.ts b/packages/api-elasticsearch/src/plugins/operator/notContains.ts
@@ -1,5 +1,5 @@
 import { ElasticsearchQueryBuilderOperatorPlugin } from "~/plugins/definition/ElasticsearchQueryBuilderOperatorPlugin";
-import { normalizeValue } from "~/normalize";
+import { normalizeValueWithAsterisk } from "~/normalize";
 import { ElasticsearchBoolQueryConfig, ElasticsearchQueryBuilderArgsPlugin } from "~/types";
 
 export class ElasticsearchQueryBuilderOperatorNotContainsPlugin extends ElasticsearchQueryBuilderOperatorPlugin {
@@ -18,7 +18,7 @@ export class ElasticsearchQueryBuilderOperatorNotContainsPlugin extends Elastics
             query_string: {
                 allow_leading_wildcard: true,
                 fields: [basePath],
-                query: `*${normalizeValue(value)}*`,
+                query: normalizeValueWithAsterisk(value),
                 default_operator: "and"
             }
         });

diff --git a/packages/api-headless-cms/__tests__/contentAPI/search.test.ts b/packages/api-headless-cms/__tests__/contentAPI/search.test.ts
@@ -22,8 +22,8 @@ describe("search", () => {
         return `A ${fruit} a`;
     };
 
-    const createFruits = async () => {
-        const fruits = ["strawb-erry", "straw-berry", "strawberry"];
+    const createFruits = async (input?: string[]) => {
+        const fruits = input || ["strawb-erry", "straw-berry", "strawberry"];
 
         return Promise.all(
             fruits.map(fruit => {
@@ -39,13 +39,13 @@ describe("search", () => {
         );
     };
 
-    const setupFruits = async () => {
+    const setupFruits = async (input?: string[]) => {
         const group = await setupContentModelGroup(fruitManager);
         await setupContentModels(fruitManager, group, ["fruit"]);
-        return createFruits();
+        return createFruits(input);
     };
 
-    it("should find record with dash in the middle of two words", async () => {
+    it.skip("should find record with dash in the middle of two words", async () => {
         await setupFruits();
         const [response] = await listFruits({
             where: {
@@ -66,4 +66,269 @@ describe("search", () => {
             }
         });
     });
+
+    it("should find record with w/ in title", async () => {
+        const fruits = {
+            apple: "app w/ le",
+            banana: "banana w/",
+            orange: "w/ orange",
+            grape: "gr w/ ape"
+        };
+        await setupFruits(Object.values(fruits));
+
+        const [initialResponse] = await listFruits({
+            sort: ["createdOn_ASC"]
+        });
+        expect(initialResponse).toMatchObject({
+            data: {
+                listFruits: {
+                    data: expect.any(Array),
+                    meta: {
+                        totalCount: 4,
+                        hasMoreItems: false,
+                        cursor: null
+                    },
+                    error: null
+                }
+            }
+        });
+        /**
+         * Apple
+         */
+        const [appleOnEnd] = await listFruits({
+            where: {
+                name_contains: "app w/"
+            }
+        });
+        expect(appleOnEnd).toMatchObject({
+            data: {
+                listFruits: {
+                    data: [
+                        {
+                            name: createName(fruits.apple)
+                        }
+                    ],
+                    meta: {
+                        totalCount: 1,
+                        hasMoreItems: false,
+                        cursor: null
+                    },
+                    error: null
+                }
+            }
+        });
+
+        const [appleOnStart] = await listFruits({
+            where: {
+                name_contains: "w/ le"
+            }
+        });
+        expect(appleOnStart).toMatchObject({
+            data: {
+                listFruits: {
+                    data: [
+                        {
+                            name: createName(fruits.apple)
+                        }
+                    ],
+                    meta: {
+                        totalCount: 1,
+                        hasMoreItems: false,
+                        cursor: null
+                    },
+                    error: null
+                }
+            }
+        });
+
+        const [appleInMiddle] = await listFruits({
+            where: {
+                name_contains: "p w/ l"
+            }
+        });
+        expect(appleInMiddle).toMatchObject({
+            data: {
+                listFruits: {
+                    data: [
+                        {
+                            name: createName(fruits.apple)
+                        }
+                    ],
+                    meta: {
+                        totalCount: 1,
+                        hasMoreItems: false,
+                        cursor: null
+                    },
+                    error: null
+                }
+            }
+        });
+        /**
+         * Banana
+         */
+        const [bananaOnEnd] = await listFruits({
+            where: {
+                name_contains: "ana w/"
+            }
+        });
+        expect(bananaOnEnd).toMatchObject({
+            data: {
+                listFruits: {
+                    data: [
+                        {
+                            name: createName(fruits.banana)
+                        }
+                    ],
+                    meta: {
+                        totalCount: 1,
+                        hasMoreItems: false,
+                        cursor: null
+                    },
+                    error: null
+                }
+            }
+        });
+
+        const [bananaInMiddle] = await listFruits({
+            where: {
+                name_contains: "banana w/"
+            }
+        });
+        expect(bananaInMiddle).toMatchObject({
+            data: {
+                listFruits: {
+                    data: [
+                        {
+                            name: createName(fruits.banana)
+                        }
+                    ],
+                    meta: {
+                        totalCount: 1,
+                        hasMoreItems: false,
+                        cursor: null
+                    },
+                    error: null
+                }
+            }
+        });
+        /**
+         * Orange
+         */
+        const [orangeOnStart] = await listFruits({
+            where: {
+                name_contains: "w/ ora"
+            }
+        });
+        expect(orangeOnStart).toMatchObject({
+            data: {
+                listFruits: {
+                    data: [
+                        {
+                            name: createName(fruits.orange)
+                        }
+                    ],
+                    meta: {
+                        totalCount: 1,
+                        hasMoreItems: false,
+                        cursor: null
+                    },
+                    error: null
+                }
+            }
+        });
+
+        const [orangeInMiddle] = await listFruits({
+            where: {
+                name_contains: "w/ orange"
+            }
+        });
+        expect(orangeInMiddle).toMatchObject({
+            data: {
+                listFruits: {
+                    data: [
+                        {
+                            name: createName(fruits.orange)
+                        }
+                    ],
+                    meta: {
+                        totalCount: 1,
+                        hasMoreItems: false,
+                        cursor: null
+                    },
+                    error: null
+                }
+            }
+        });
+        /**
+         * Grape
+         */
+        const [grapeOnEnd] = await listFruits({
+            where: {
+                name_contains: "gr w/"
+            }
+        });
+        expect(grapeOnEnd).toMatchObject({
+            data: {
+                listFruits: {
+                    data: [
+                        {
+                            name: createName(fruits.grape)
+                        }
+                    ],
+                    meta: {
+                        totalCount: 1,
+                        hasMoreItems: false,
+                        cursor: null
+                    },
+                    error: null
+                }
+            }
+        });
+
+        const [grapeOnStart] = await listFruits({
+            where: {
+                name_contains: "w/ ape"
+            }
+        });
+        expect(grapeOnStart).toMatchObject({
+            data: {
+                listFruits: {
+                    data: [
+                        {
+                            name: createName(fruits.grape)
+                        }
+                    ],
+                    meta: {
+                        totalCount: 1,
+                        hasMoreItems: false,
+                        cursor: null
+                    },
+                    error: null
+                }
+            }
+        });
+
+        const [grapeInMiddle] = await listFruits({
+            where: {
+                name_contains: "r w/ ap"
+            }
+        });
+        expect(grapeInMiddle).toMatchObject({
+            data: {
+                listFruits: {
+                    data: [
+                        {
+                            name: createName(fruits.grape)
+                        }
+                    ],
+                    meta: {
+                        totalCount: 1,
+                        hasMoreItems: false,
+                        cursor: null
+                    },
+                    error: null
+                }
+            }
+        });
+    });
 });