feat(core): allow querying by JSON properties

We can query by JSON object properties easily:

```ts
const b = await em.findOne(Book, {
  meta: {
    valid: true,
    nested: {
      foo: '123',
      bar: 321,
      deep: {
        baz: 59,
        qux: false,
      },
    },
  },
});
```

Will produce following query (in postgres):

```sql
select "e0".*
from "book" as "e0"
where ("meta"->>'valid')::bool = true
  and "meta"->'nested'->>'foo' = '123'
  and ("meta"->'nested'->>'bar')::float8 = 321
  and ("meta"->'nested'->'deep'->>'baz')::float8 = 59
  and ("meta"->'nested'->'deep'->>'qux')::bool = false
limit 1
```

> All drivers are currently supported (including sqlite and mongo). In postgres we
> also try to cast the value if we detect number or boolean on the right-hand side.

Closes #1359
Related: #1261

docs/docs/json-properties.md

@@ -0,0 +1,57 @@
+---
+title: Using JSON properties
+---
+
+## Defining JSON properties
+
+Each database driver behaves a bit differently when it comes to JSON properties.
+MikroORM tries to unify the experience via [JsonType](custom-types.md#jsontype).
+This type will be also used if you specify `type: 'json'`.
+
+```ts
+@Entity()
+export class Book {
+
+  @Property({ type: 'json', nullable: true })
+  meta?: { foo: string; bar: number };
+
+}
+```
+
+## Querying by JSON object properties
+
+> Support for querying by JSON object properties was added in v4.4.2
+
+We can query by JSON object properties easily:
+
+```ts
+const b = await em.findOne(Book, {
+  meta: {
+    valid: true,
+    nested: { 
+      foo: '123', 
+      bar: 321, 
+      deep: { 
+        baz: 59,
+        qux: false,
+      },
+    },
+  },
+});
+```
+
+Will produce following query (in postgres):
+
+```sql
+select "e0".* 
+from "book" as "e0" 
+where ("meta"->>'valid')::bool = true 
+  and "meta"->'nested'->>'foo' = '123' 
+  and ("meta"->'nested'->>'bar')::float8 = 321 
+  and ("meta"->'nested'->'deep'->>'baz')::float8 = 59 
+  and ("meta"->'nested'->'deep'->>'qux')::bool = false 
+limit 1
+```
+
+> All drivers are currently supported (including sqlite and mongo). In postgres we
+> also try to cast the value if we detect number or boolean on the right-hand side.

docs/sidebars.js

@@ -33,6 +33,7 @@ module.exports = {
       'custom-types',
       'embeddables',
       'entity-schema',
+      'json-properties',
       'metadata-providers',
       'metadata-cache',
       'schema-generator',

docs/versioned_docs/version-4.4/json-properties.md

@@ -0,0 +1,57 @@
+---
+title: Using JSON properties
+---
+
+## Defining JSON properties
+
+Each database driver behaves a bit differently when it comes to JSON properties. 
+MikroORM tries to unify the experience via [JsonType](custom-types.md#jsontype). 
+This type will be also used if you specify `type: 'json'`. 
+
+```ts
+@Entity()
+export class Book {
+
+  @Property({ type: 'json', nullable: true })
+  meta?: { foo: string; bar: number };
+
+}
+```
+
+## Querying by JSON object properties
+
+> Support for querying by JSON object properties was added in v4.4.2
+
+We can query by JSON object properties easily:
+
+```ts
+const b = await em.findOne(Book, {
+  meta: {
+    valid: true,
+    nested: { 
+      foo: '123', 
+      bar: 321, 
+      deep: { 
+        baz: 59,
+        qux: false,
+      },
+    },
+  },
+});
+```
+
+Will produce following query (in postgres):
+
+```sql
+select "e0".* 
+from "book" as "e0" 
+where ("meta"->>'valid')::bool = true 
+  and "meta"->'nested'->>'foo' = '123' 
+  and ("meta"->'nested'->>'bar')::float8 = 321 
+  and ("meta"->'nested'->'deep'->>'baz')::float8 = 59 
+  and ("meta"->'nested'->'deep'->>'qux')::bool = false 
+limit 1
+```
+
+> All drivers are currently supported (including sqlite and mongo). In postgres we
+> also try to cast the value if we detect number or boolean on the right-hand side.

docs/versioned_sidebars/version-4.4-sidebars.json

@@ -131,6 +131,10 @@
           "type": "doc",
           "id": "version-4.4/entity-schema"
         },
+        {
+          "type": "doc",
+          "id": "version-4.4/json-properties"
+        },
         {
           "type": "doc",
           "id": "version-4.4/metadata-providers"

packages/core/src/metadata/MetadataDiscovery.ts

@@ -602,7 +602,7 @@ export class MetadataDiscovery {
         path.unshift(this.namingStrategy.propertyToColumnName(rootProperty.name));
         path.push(prop.name);
 
-        meta.properties[name].fieldNameRaw = this.platform.getSearchJsonPropertySQL(path.join('->')); // for querying in SQL drivers
+        meta.properties[name].fieldNameRaw = this.platform.getSearchJsonPropertySQL(path.join('->'), prop.type); // for querying in SQL drivers
         meta.properties[name].persist = false; // only virtual as we store the whole object
       }
 

packages/core/src/platforms/Platform.ts

@@ -161,10 +161,14 @@ export abstract class Platform {
     return 'json';
   }
 
-  getSearchJsonPropertySQL(path: string): string {
+  getSearchJsonPropertySQL(path: string, type: string): string {
     return path;
   }
 
+  getSearchJsonPropertyKey(path: string[], type: string): string {
+    return path.join('.');
+  }
+
   convertsJsonAutomatically(marshall = false): boolean {
     return !marshall;
   }

packages/core/src/utils/QueryHelper.ts

@@ -4,6 +4,7 @@ import { AnyEntity, Dictionary, EntityMetadata, EntityProperty, FilterDef, Filte
 import { ARRAY_OPERATORS, GroupOperator } from '../enums';
 import { Platform } from '../platforms';
 import { MetadataStorage } from '../metadata/MetadataStorage';
+import { JsonType } from '../types';
 
 export class QueryHelper {
 
@@ -118,6 +119,10 @@ export class QueryHelper {
         value = QueryHelper.processCustomType(prop, value, platform, undefined, true);
       }
 
+      if (prop?.customType instanceof JsonType && Utils.isPlainObject(value)) {
+        return this.processJsonCondition(o, value, [key], platform);
+      }
+
       if (Array.isArray(value) && !Utils.isOperator(key) && !QueryHelper.isSupportedOperator(key) && !key.includes('?')) {
         if (platform.allowsComparingTuples()) {
           // comparing single composite key - use $eq instead of $in
@@ -193,7 +198,7 @@ export class QueryHelper {
   static processCustomType<T>(prop: EntityProperty<T>, cond: FilterQuery<T>, platform: Platform, key?: string, fromQuery?: boolean): FilterQuery<T> {
     if (Utils.isPlainObject(cond)) {
       return Object.keys(cond).reduce((o, k) => {
-        if (Utils.isOperator(k, true) || prop.referencedPKs.includes(k)) {
+        if (Utils.isOperator(k, true) || prop.referencedPKs?.includes(k)) {
           o[k] = QueryHelper.processCustomType(prop, cond[k], platform, k, fromQuery);
         } else {
           o[k] = cond[k];
@@ -236,6 +241,21 @@ export class QueryHelper {
     return !!QueryHelper.SUPPORTED_OPERATORS.find(op => key.includes(op));
   }
 
+  private static processJsonCondition<T>(o: FilterQuery<T>, value: Dictionary, path: string[], platform: Platform) {
+    if (Utils.isPlainObject(value)) {
+      Object.keys(value).forEach(k => {
+        this.processJsonCondition(o, value[k], [...path, k], platform);
+      });
+
+      return o;
+    }
+
+    const k = platform.getSearchJsonPropertyKey(path, typeof value);
+    o[k] = value;
+
+    return o;
+  }
+
 }
 
 export const expr = (sql: string) => sql;

packages/knex/src/AbstractSqlPlatform.ts

@@ -66,4 +66,8 @@ export abstract class AbstractSqlPlatform extends Platform {
     return ret;
   }
 
+  getSearchJsonPropertySQL(path: string, type: string): string {
+    return this.getSearchJsonPropertyKey(path.split('->'), type);
+  }
+
 }

packages/mysql-base/src/MySqlPlatform.ts

@@ -11,9 +11,9 @@ export class MySqlPlatform extends AbstractSqlPlatform {
     return 'utf8mb4';
   }
 
-  getSearchJsonPropertySQL(path: string): string {
-    const [a, b] = path.split('->', 2); // TODO
-    return `${this.quoteIdentifier(a)}->'$.${b}'`;
+  getSearchJsonPropertyKey(path: string[], type: string): string {
+    const [a, ...b] = path;
+    return `${this.quoteIdentifier(a)}->'$.${b.join('.')}'`;
   }
 
 }

packages/postgresql/src/PostgreSqlPlatform.ts

@@ -58,17 +58,20 @@ export class PostgreSqlPlatform extends AbstractSqlPlatform {
     return 'jsonb';
   }
 
-  getSearchJsonPropertySQL(path: string): string {
-    const parts = path.split('->');
-    const first = parts.shift();
-    const last = parts.pop();
+  getSearchJsonPropertyKey(path: string[], type: string): string {
+    const first = path.shift();
+    const last = path.pop();
     const root = this.quoteIdentifier(first!);
+    const cast = (key: string) => {
+      const t = type === 'number' ? 'float8' : (type === 'boolean' ? 'bool' : '');
+      return t ? `(${key})::${t}` : key;
+    };
 
-    if (parts.length === 0) {
-      return `${root}->>'${last}'`;
+    if (path.length === 0) {
+      return cast(`${root}->>'${last}'`);
     }
 
-    return `${root}->${parts.map(a => this.quoteValue(a)).join('->')}->>'${last}'`;
+    return cast(`${root}->${path.map(a => this.quoteValue(a)).join('->')}->>'${last}'`);
   }
 
   quoteIdentifier(id: string, quote = '"'): string {

packages/sqlite/src/SqlitePlatform.ts

@@ -69,4 +69,9 @@ export class SqlitePlatform extends AbstractSqlPlatform {
     return escape(value, true, this.timezone);
   }
 
+  getSearchJsonPropertyKey(path: string[], type: string): string {
+    const [a, ...b] = path;
+    return `json_extract(${this.quoteIdentifier(a)}, '$.${b.join('.')}')`;
+  }
+
 }

tests/EntityManager.mongo.test.ts

@@ -594,6 +594,36 @@ describe('EntityManagerMongo', () => {
     await expect(conn4.getClientUrl()).toBe('invalid-url-that-was-not-properly-parsed');
   });
 
+  test('json properties', async () => {
+    const god = new Author('God', 'hello@heaven.god');
+    god.identities = ['fb-123', 'pw-231', 'tw-321'];
+    const bible = new Book('Bible', god);
+    bible.metaObject = { category: 'god like', items: 3, valid: true, nested: { foo: '123', bar: 321, deep: { baz: 59, qux: false } } };
+    await orm.em.persistAndFlush(bible);
+    orm.em.clear();
+
+    const g = await orm.em.findOneOrFail(Author, god.id, ['books']);
+    expect(Array.isArray(g.identities)).toBe(true);
+    expect(g.identities).toEqual(['fb-123', 'pw-231', 'tw-321']);
+    expect(typeof g.books[0].metaObject).toBe('object');
+    expect(g.books[0].metaObject).toEqual({ category: 'god like', items: 3, valid: true, nested: { foo: '123', bar: 321, deep: { baz: 59, qux: false } } });
+    orm.em.clear();
+
+    const b1 = await orm.em.findOneOrFail(Book, { metaObject: { category: 'god like' } });
+    const b2 = await orm.em.findOneOrFail(Book, { metaObject: { category: 'god like', items: 3 } });
+    const b3 = await orm.em.findOneOrFail(Book, { metaObject: { nested: { bar: 321 } } });
+    const b4 = await orm.em.findOneOrFail(Book, { metaObject: { nested: { foo: '123', bar: 321 } } });
+    const b5 = await orm.em.findOneOrFail(Book, { metaObject: { valid: true, nested: { foo: '123', bar: 321 } } });
+    const b6 = await orm.em.findOneOrFail(Book, { metaObject: { valid: true, nested: { foo: '123', bar: 321, deep: { baz: 59 } } } });
+    const b7 = await orm.em.findOneOrFail(Book, { metaObject: { valid: true, nested: { foo: '123', bar: 321, deep: { baz: 59, qux: false } } } });
+    expect(b1).toBe(b2);
+    expect(b1).toBe(b3);
+    expect(b1).toBe(b4);
+    expect(b1).toBe(b5);
+    expect(b1).toBe(b6);
+    expect(b1).toBe(b7);
+  });
+
   test('findOne by id', async () => {
     const authorRepository = orm.em.getRepository(Author);
     const jon = new Author('Jon Snow', 'snow@wall.st');

tests/EntityManager.mysql.test.ts

@@ -525,15 +525,30 @@ describe('EntityManagerMySql', () => {
     const god = new Author2('God', 'hello@heaven.god');
     god.identities = ['fb-123', 'pw-231', 'tw-321'];
     const bible = new Book2('Bible', god);
-    bible.meta = { category: 'god like', items: 3 };
+    bible.meta = { category: 'god like', items: 3, valid: true, nested: { foo: '123', bar: 321, deep: { baz: 59, qux: false } } };
     await orm.em.persistAndFlush(bible);
     orm.em.clear();
 
-    const g = (await orm.em.findOne(Author2, god.id, ['books']))!;
+    const g = await orm.em.findOneOrFail(Author2, god.id, ['books']);
     expect(Array.isArray(g.identities)).toBe(true);
     expect(g.identities).toEqual(['fb-123', 'pw-231', 'tw-321']);
     expect(typeof g.books[0].meta).toBe('object');
-    expect(g.books[0].meta).toEqual({ category: 'god like', items: 3 });
+    expect(g.books[0].meta).toEqual({ category: 'god like', items: 3, valid: true, nested: { foo: '123', bar: 321, deep: { baz: 59, qux: false } } });
+    orm.em.clear();
+
+    const b1 = await orm.em.findOneOrFail(Book2, { meta: { category: 'god like' } });
+    const b2 = await orm.em.findOneOrFail(Book2, { meta: { category: 'god like', items: 3 } });
+    const b3 = await orm.em.findOneOrFail(Book2, { meta: { nested: { bar: 321 } } });
+    const b4 = await orm.em.findOneOrFail(Book2, { meta: { nested: { foo: '123', bar: 321 } } });
+    const b5 = await orm.em.findOneOrFail(Book2, { meta: { valid: true, nested: { foo: '123', bar: 321 } } });
+    const b6 = await orm.em.findOneOrFail(Book2, { meta: { valid: true, nested: { foo: '123', bar: 321, deep: { baz: 59 } } } });
+    const b7 = await orm.em.findOneOrFail(Book2, { meta: { valid: true, nested: { foo: '123', bar: 321, deep: { baz: 59, qux: false } } } });
+    expect(b1).toBe(b2);
+    expect(b1).toBe(b3);
+    expect(b1).toBe(b4);
+    expect(b1).toBe(b5);
+    expect(b1).toBe(b6);
+    expect(b1).toBe(b7);
   });
 
   test('findOne should initialize entity that is already in IM', async () => {

tests/EntityManager.postgre.test.ts

@@ -393,15 +393,30 @@ describe('EntityManagerPostgre', () => {
     const god = new Author2('God', 'hello@heaven.god');
     god.identities = ['fb-123', 'pw-231', 'tw-321'];
     const bible = new Book2('Bible', god);
-    bible.meta = { category: 'god like', items: 3 };
+    bible.meta = { category: 'god like', items: 3, valid: true, nested: { foo: '123', bar: 321, deep: { baz: 59, qux: false } } };
     await orm.em.persistAndFlush(bible);
     orm.em.clear();
 
-    const g = (await orm.em.findOne(Author2, god.id, ['books']))!;
+    const g = await orm.em.findOneOrFail(Author2, god.id, ['books']);
     expect(Array.isArray(g.identities)).toBe(true);
     expect(g.identities).toEqual(['fb-123', 'pw-231', 'tw-321']);
     expect(typeof g.books[0].meta).toBe('object');
-    expect(g.books[0].meta).toEqual({ category: 'god like', items: 3 });
+    expect(g.books[0].meta).toEqual({ category: 'god like', items: 3, valid: true, nested: { foo: '123', bar: 321, deep: { baz: 59, qux: false } } });
+    orm.em.clear();
+
+    const b1 = await orm.em.findOneOrFail(Book2, { meta: { category: 'god like' } });
+    const b2 = await orm.em.findOneOrFail(Book2, { meta: { category: 'god like', items: 3 } });
+    const b3 = await orm.em.findOneOrFail(Book2, { meta: { nested: { bar: 321 } } });
+    const b4 = await orm.em.findOneOrFail(Book2, { meta: { nested: { foo: '123', bar: 321 } } });
+    const b5 = await orm.em.findOneOrFail(Book2, { meta: { valid: true, nested: { foo: '123', bar: 321 } } });
+    const b6 = await orm.em.findOneOrFail(Book2, { meta: { valid: true, nested: { foo: '123', bar: 321, deep: { baz: 59 } } } });
+    const b7 = await orm.em.findOneOrFail(Book2, { meta: { valid: true, nested: { foo: '123', bar: 321, deep: { baz: 59, qux: false } } } });
+    expect(b1).toBe(b2);
+    expect(b1).toBe(b3);
+    expect(b1).toBe(b4);
+    expect(b1).toBe(b5);
+    expect(b1).toBe(b6);
+    expect(b1).toBe(b7);
   });
 
   test('findOne should initialize entity that is already in IM', async () => {