feat(minato): support logical exprs in querying to-many relation (#107)

packages/core/src/database.ts

@@ -636,6 +636,9 @@ export class Database<S = {}, N = {}, C extends Context = Context> extends Servi
         ))
       }
     } else if (relation.type === 'oneToMany') {
+      if (query.$or) results.push(Eval.or(...query.$or.map((q: any) => this.transformRelationQuery(table, row, key, q).$expr)))
+      if (query.$and) results.push(...query.$and.map((q: any) => this.transformRelationQuery(table, row, key, q).$expr))
+      if (query.$not) results.push(Eval.not(this.transformRelationQuery(table, row, key, query.$not).$expr))
       if (query.$some) {
         results.push(Eval.in(
           relation.fields.map(x => row[x]),
@@ -658,6 +661,9 @@ export class Database<S = {}, N = {}, C extends Context = Context> extends Servi
       const assocTable: any = Relation.buildAssociationTable(table, relation.table)
       const fields: any[] = relation.fields.map(x => Relation.buildAssociationKey(x, table))
       const references = relation.references.map(x => Relation.buildAssociationKey(x, relation.table))
+      if (query.$or) results.push(Eval.or(...query.$or.map((q: any) => this.transformRelationQuery(table, row, key, q).$expr)))
+      if (query.$and) results.push(...query.$and.map((q: any) => this.transformRelationQuery(table, row, key, q).$expr))
+      if (query.$not) results.push(Eval.not(this.transformRelationQuery(table, row, key, query.$not).$expr))
       if (query.$some) {
         const innerTable = this.select(relation.table, query.$some).evaluate(relation.references)
         const relTable = this.select(assocTable, r => Eval.in(references.map(x => r[x]), innerTable)).evaluate(fields)

packages/mongo/tests/migration.spec.ts

@@ -1,8 +1,7 @@
-import { $, Database, Primary } from 'minato'
+import { $, Database, Driver, Primary } from 'minato'
 import { Context, ForkScope, Logger } from 'cordis'
-import { expect } from 'chai'
 import MongoDriver from '@minatojs/driver-mongo'
-import '@minatojs/tests'
+import { expect } from '@minatojs/tests'
 
 const logger = new Logger('mongo')
 
@@ -105,11 +104,11 @@ describe('@minatojs/driver-mongo/migrate-virtualKey', () => {
     await resetConfig(false)
     await expect(database.get('temp1', {})).to.eventually.deep.eq(table)
 
-    await (Object.values(database.drivers)[0] as MongoDriver).drop('_fields')
+    await (Object.values(database.drivers)[0] as Driver).drop('_fields')
     await resetConfig(true)
     await expect(database.get('temp1', {})).to.eventually.deep.eq(table)
 
-    await (Object.values(database.drivers)[0] as MongoDriver).drop('_fields')
+    await (Object.values(database.drivers)[0] as Driver).drop('_fields')
     await resetConfig(false)
     await expect(database.get('temp1', {})).to.eventually.deep.eq(table)
   })
@@ -139,11 +138,11 @@ describe('@minatojs/driver-mongo/migrate-virtualKey', () => {
     table.push(await database.create('temp2', { text: 'awesome baz' }))
     await expect(database.get('temp2', {})).to.eventually.deep.eq(table)
 
-    await (Object.values(database.drivers)[0] as MongoDriver).drop('_fields')
+    await (Object.values(database.drivers)[0] as Driver).drop('_fields')
     await resetConfig(true)
     await expect(database.get('temp2', {})).to.eventually.deep.eq(table)
 
-    await (Object.values(database.drivers)[0] as MongoDriver).drop('_fields')
+    await (Object.values(database.drivers)[0] as Driver).drop('_fields')
     await resetConfig(false)
     await expect(database.get('temp2', {})).to.eventually.deep.eq(table)
 

packages/tests/src/index.ts

@@ -10,6 +10,8 @@ import Transaction from './transaction'
 import Relation from './relation'
 import './setup'
 
+export { expect } from 'chai'
+
 const Keywords = ['name']
 type Keywords = 'name'
 

packages/tests/src/relation.ts

@@ -452,6 +452,43 @@ namespace RelationTests {
         ...user,
         posts: posts.filter(post => post.author?.id === user.id),
       })))
+
+      await expect(database.get('user', {
+        posts: {
+          $or: [
+            {
+              $some: {
+                author: {
+                  id: 1,
+                },
+              },
+            },
+            {
+              $none: {
+                author: {},
+              },
+            },
+          ],
+        },
+      })).to.eventually.have.shape([users[0], users[2]].map(user => ({
+        ...user,
+        posts: posts.filter(post => post.author?.id === user.id),
+      })))
+
+      await expect(database.get('user', {
+        posts: {
+          $not: {
+            $some: {
+              author: {
+                id: 1,
+              },
+            },
+          },
+        },
+      })).to.eventually.have.shape([users[1], users[2]].map(user => ({
+        ...user,
+        posts: posts.filter(post => post.author?.id === user.id),
+      })))
     })
 
     it('manyToMany', async () => {

yakumo.yml

@@ -6,6 +6,7 @@
         - esbuild
       clean:
         - tsc --clean
+- name: yakumo/run
 - name: yakumo-esbuild
 - name: yakumo-mocha
 - name: yakumo-tsc