feat(index): Provide a similar API to Query (#9193)

**What**
Align the index engine API to be similar to the Query API

## Example

```ts
        // Benefit from the same level of typing like the remote query

        const { data, metadata } = await indexEngine.query<'product'>({
          fields: [
            "product.*",
            "product.variants.*",
            "product.variants.prices.*",
          ],
          filters: {
            product: {
              variants: {
                prices: {
                  amount: { $gt: 50 },
                },
              },
            },
          },
          pagination: {
            order: {
              product: {
                variants: {
                  prices: {
                    amount: "DESC",
                  },
                },
              },
            },
          },
        })
```

packages/modules/index/src/utils/query-builder.ts

@@ -1,14 +1,21 @@
 import { isObject, isString } from "@medusajs/utils"
+import { IndexTypes } from "@medusajs/types"
 import { GraphQLList } from "graphql"
 import { Knex } from "knex"
-import {
-  OrderBy,
-  QueryFormat,
-  QueryOptions,
-  SchemaObjectRepresentation,
-  SchemaPropertiesMap,
-  Select,
-} from "../types"
+import { OrderBy, QueryFormat, QueryOptions, Select } from "@types"
+
+export const OPERATOR_MAP = {
+  $eq: "=",
+  $lt: "<",
+  $gt: ">",
+  $lte: "<=",
+  $gte: ">=",
+  $ne: "!=",
+  $in: "IN",
+  $is: "IS",
+  $like: "LIKE",
+  $ilike: "ILIKE",
+}
 
 export class QueryBuilder {
   private readonly structure: Select
@@ -16,10 +23,10 @@ export class QueryBuilder {
   private readonly knex: Knex
   private readonly selector: QueryFormat
   private readonly options?: QueryOptions
-  private readonly schema: SchemaObjectRepresentation
+  private readonly schema: IndexTypes.SchemaObjectRepresentation
 
   constructor(args: {
-    schema: SchemaObjectRepresentation
+    schema: IndexTypes.SchemaObjectRepresentation
     entityMap: Record<string, any>
     knex: Knex
     selector: QueryFormat
@@ -37,7 +44,7 @@ export class QueryBuilder {
     return Object.keys(structure ?? {}).filter((key) => key !== "entity")
   }
 
-  private getEntity(path): SchemaPropertiesMap[0] {
+  private getEntity(path): IndexTypes.SchemaPropertiesMap[0] {
     if (!this.schema._schemaPropertiesMap[path]) {
       throw new Error(`Could not find entity for path: ${path}`)
     }
@@ -119,18 +126,6 @@ export class QueryBuilder {
     obj: object,
     builder: Knex.QueryBuilder
   ) {
-    const OPERATOR_MAP = {
-      $eq: "=",
-      $lt: "<",
-      $gt: ">",
-      $lte: "<=",
-      $gte: ">=",
-      $ne: "!=",
-      $in: "IN",
-      $is: "IS",
-      $like: "LIKE",
-      $ilike: "ILIKE",
-    }
     const keys = Object.keys(obj)
 
     const getPathAndField = (key: string) => {