vona-module-test-vona 5.0.39 → 5.0.42

package/test/cache/caching.test.ts

@@ -0,0 +1,58 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('caching.test.ts', () => {
+  it('action:caching', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const scopeTest = app.bean.scope('test-vona');
+      // get: cacheKeyFn(string)
+      const res = await scopeTest.service.caching.get(2);
+      assert.equal(res.id, 2);
+      // get: cacheKeyFn(function)
+      const res2 = await scopeTest.service.caching.get2(2);
+      assert.equal(res.id, res2.id);
+      // get: cacheKey(celjs expression)
+      const res3 = await scopeTest.service.caching.get3(2);
+      assert.equal(res.id, res3.id);
+      // get: cacheKey(default)
+      const res4 = await scopeTest.service.caching.get4(2);
+      assert.equal(res.id, res4.id);
+      // get: cacheKey(default) not hit cache
+      const res5 = await scopeTest.service.caching.get4(5);
+      assert.equal(res5, undefined);
+      // set: cacheKeyFn/cacheValueFn
+      await scopeTest.service.caching.set(2, { ...res, name: `${res.name}!` });
+      // get again
+      const res6 = await scopeTest.service.caching.get4(2);
+      assert.equal(res.id, res6.id);
+      assert.equal(`${res.name}!`, res6.name);
+      // set: cacheKey/cacheValue
+      await scopeTest.service.caching.set2(2, { ...res, name: `${res.name}!` });
+      // get again
+      const res7 = await scopeTest.service.caching.get4(2);
+      assert.equal(res.id, res7.id);
+      assert.equal(`${res.name}!`, res7.name);
+      // set: no cacheValue/cacheValueFn
+      await scopeTest.service.caching.set3(2, { ...res, name: `${res.name}!` });
+      // get again
+      const res8 = await scopeTest.service.caching.get4(2);
+      assert.equal(res.id, res8.id);
+      assert.equal(`${res.name}!`, res8.name);
+      // del
+      await scopeTest.service.caching.del(2);
+      // get again
+      const res9 = await scopeTest.service.caching.get4(2);
+      assert.equal(res9, undefined);
+      // cache again
+      const res10 = await scopeTest.service.caching.get(2);
+      assert.equal(res10.id, 2);
+      const res11 = await scopeTest.service.caching.get4(2);
+      assert.equal(res11.id, 2);
+      // clear
+      await scopeTest.service.caching.clear();
+      const res12 = await scopeTest.service.caching.get4(2);
+      assert.equal(res12, undefined);
+    });
+  });
+});

package/test/cache/summer.test.ts

@@ -0,0 +1,10 @@
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('summer.test.ts', () => {
+  it('action:summer', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.executor.performAction('post', '/test/vona/summer');
+    });
+  });
+});

package/test/database/database.test.ts

@@ -0,0 +1,127 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { catchError } from '@cabloy/utils';
+import moment from 'moment';
+import { app } from 'vona-mock';
+
+describe('database.test.ts', () => {
+  it('action:database:switchClient', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const scopeDatabase = app.bean.scope('a-orm');
+      const defaultClientName = scopeDatabase.service.database.getDefaultClientName();
+      // current
+      assert.equal(app.ctx.db.clientName, defaultClientName);
+      // switch
+      const clientNames = Object.keys(app.config.database.clients);
+      const clientName2 = clientNames.find(item => item !== defaultClientName);
+      await app.bean.database.switchDb(async () => {
+        assert.equal(app.ctx.db.clientName, clientName2);
+      }, { clientName: clientName2 as any });
+      // restore
+      assert.equal(app.ctx.db.clientName, defaultClientName);
+    });
+  });
+  it('action:model:clientName', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      const modelTest = scopeTest.model.test;
+      assert.equal(modelTest.options.client, 'default');
+      const modelTest2 = scopeTest.model.test;
+      assert.equal(modelTest, modelTest2);
+    });
+  });
+  it('action:model:clientNameDynamic:transaction:fail', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      const entityTest = await scopeTest.model.test.insert({ title: 'clientNameDynamic:fail' });
+      assert.equal(entityTest.title, 'clientNameDynamic:fail');
+      await catchError(async () => {
+        const db = app.bean.database.getDb({ clientName: 'default' });
+        await db.transaction.begin(async () => {
+          const modelTest = scopeTest.model.test.newInstance(db);
+          assert.equal(modelTest.options.client, 'default');
+          await modelTest.update({ id: entityTest.id, title: 'clientNameDynamic:fail_1' });
+          throw new Error('rollback');
+        });
+      });
+      const entityTest2 = await scopeTest.model.test.get({ id: entityTest.id });
+      assert.equal(entityTest2?.title, 'clientNameDynamic:fail');
+      // delete
+      await scopeTest.model.test.delete({ id: entityTest.id });
+    });
+  });
+  it('action:model:clientNameDynamic:transaction:success', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      const entityTest = await scopeTest.model.test.insert({ title: 'clientNameDynamic:success' });
+      assert.equal(entityTest.title, 'clientNameDynamic:success');
+      const db = app.bean.database.getDb({ clientName: 'default' });
+      await db.transaction.begin(async () => {
+        const modelTest = scopeTest.model.test.newInstance(db);
+        assert.equal(modelTest.options.client, 'default');
+        await modelTest.update({ id: entityTest.id, title: 'clientNameDynamic:success_1' });
+      });
+      const entityTest2 = await scopeTest.model.test.get({ id: entityTest.id });
+      assert.equal(entityTest2?.title, 'clientNameDynamic:success_1');
+      // delete
+      await scopeTest.model.test.delete({ id: entityTest.id });
+    });
+  });
+  it('action:database:transaction:compensate', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      const entityTest = await scopeTest.model.test.insert({ title: 'transaction:compensate:fail' });
+      assert.equal(entityTest.title, 'transaction:compensate:fail');
+      await catchError(async () => {
+        const db = app.bean.database.getDb({ clientName: 'default' });
+        await db.transaction.begin(async () => {
+          const modelTest = scopeTest.model.test.newInstance(db);
+          assert.equal(modelTest.options.client, 'default');
+          await modelTest.update({ id: entityTest.id, title: 'transaction:compensate:fail_1' });
+          // let cache take effect
+          await modelTest.get({ id: entityTest.id });
+          throw new Error('rollback');
+        });
+      });
+      const entityTest2 = await scopeTest.model.test.get({ id: entityTest.id });
+      assert.equal(entityTest2?.title, 'transaction:compensate:fail');
+      // delete
+      await scopeTest.model.test.delete({ id: entityTest.id });
+    });
+  });
+  it('action:model:dynamicTableName', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      const entityTest = scopeTest.entity.test;
+      const modelTest = scopeTest.model.testDynamicTable;
+      // tableName
+      const tableName = `${entityTest.$table}_${moment().format('YYYYMMDD')}`;
+      // create table
+      await app.bean.model.createTable(tableName, table => {
+        table.basicFields();
+        table.string(entityTest.title, 255);
+        table.string(entityTest.description, 255);
+      });
+      // insert
+      const item = await modelTest.insert({ title: 'title', description: 'description' });
+      // get
+      const item2 = await modelTest.get({ id: item.id });
+      assert.equal(item2?.id, item.id);
+      // get by tableName
+      const item3 = await app.bean.model.get(tableName as any, { id: item.id });
+      assert.equal(item3.id, item.id);
+      // delete
+      await modelTest.delete({ id: item.id });
+      // get by tableName
+      const item4 = await app.bean.model.get(tableName as any, { id: item.id });
+      assert.equal(item4, undefined);
+      // drop table
+      await app.bean.model.dropTable(tableName);
+    });
+  });
+});

package/test/database/dtoAggregate.test.ts

@@ -0,0 +1,44 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+import { getTargetDecoratorRules } from 'vona-module-a-openapi';
+import { $Dto } from 'vona-module-a-orm';
+import { ModelUserStats } from 'vona-module-test-vona';
+
+describe('dtoAggregate.test.ts', () => {
+  it('action:dtoAggregate', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.executor.mockCtx(async () => {
+        // aggr
+        const DtoUserAggr = $Dto.aggregate('test-vona:user', {
+          count: ['*', 'age'],
+          sum: ['age'],
+          avg: 'age',
+          // max: 'age',
+          // min: 'age',
+        });
+        let rules: any;
+        rules = getTargetDecoratorRules(DtoUserAggr.prototype);
+        assert.equal(rules.count_all._def.typeName, 'ZodOptional');
+        assert.equal(rules.count_all._def.innerType._def.typeName, 'ZodUnion');
+        assert.equal(rules.count_all._def.innerType._def.options[0]._def.typeName, 'ZodString');
+        assert.equal(rules.count_all._def.innerType._def.options[1]._def.typeName, 'ZodNumber');
+        assert.equal(rules.count_age._def.typeName, 'ZodOptional');
+        assert.equal(rules.sum_age._def.typeName, 'ZodOptional');
+        assert.equal(rules.avg_age._def.typeName, 'ZodOptional');
+        assert.equal(rules.max_age, undefined);
+        assert.equal(rules.min_age, undefined);
+        // aggr: usersStats: posts: autoload
+        const DtoUserStats = $Dto.get(() => ModelUserStats, {
+          columns: 'name',
+          include: { roles: true },
+        });
+        rules = getTargetDecoratorRules(DtoUserStats.prototype);
+        assert.equal(rules.name._def.typeName, 'ZodString');
+        assert.equal(rules.iid, undefined);
+        assert.equal(rules.posts._def.typeName, 'ZodOptional');
+        assert.equal(rules.roles._def.typeName, 'ZodOptional');
+      });
+    });
+  });
+});

package/test/database/dtoGet.test.ts

@@ -0,0 +1,61 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+import { getTargetDecoratorRules } from 'vona-module-a-openapi';
+import { $Dto, $relationDynamic } from 'vona-module-a-orm';
+import { ModelPost, ModelPostContent, ModelRole, ModelRoleUser, ModelUser } from 'vona-module-test-vona';
+
+describe('dtoGet.test.ts', () => {
+  it('action:dtoGet', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.executor.mockCtx(async () => {
+        const DtoPostNew = $Dto.get(ModelPost, {
+          columns: ['id', 'title', 'userId'],
+          include: {
+            postContent: {
+              columns: ['id', 'content'],
+              include: {
+                post: { include: { user: { columns: ['id'] } } },
+              },
+              with: {
+                post3: $relationDynamic.belongsTo(() => ModelPostContent, () => ModelPost, 'postId', {
+                  include: {
+                    postContent: true,
+                  },
+                }),
+              },
+            },
+          },
+          with: {
+            user3: $relationDynamic.belongsTo(ModelPost, () => ModelUser, 'userId', {
+              include: { posts: true },
+              with: { roles: $relationDynamic.belongsToMany(() => ModelRoleUser, () => ModelRole, 'userId', 'roleId') },
+              columns: ['id', 'name'],
+            }),
+          },
+        });
+        const rules: any = getTargetDecoratorRules(DtoPostNew.prototype);
+        assert.equal(['ZodString', 'ZodNumber'].includes(rules.id._def.typeName), true);
+        assert.equal(rules.title._def.typeName, 'ZodString');
+        assert.equal(['ZodString', 'ZodNumber'].includes(rules.userId._def.typeName), true);
+        assert.equal(rules.iid, undefined);
+        assert.equal(rules.postContent._def.typeName, 'ZodOptional');
+        assert.equal(rules.user._def.typeName, 'ZodOptional');
+        assert.equal(rules.user3._def.typeName, 'ZodOptional');
+      });
+    });
+  });
+  it('action:dtoGet:categoryTree', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.executor.mockCtx(async () => {
+        const DtoCategoryTree = $Dto.get('test-vona:category', { columns: ['id', 'name'], include: { children: { columns: ['id'] } } });
+        const rules: any = getTargetDecoratorRules(DtoCategoryTree.prototype);
+        assert.equal(rules.children._def.typeName, 'ZodEffects');
+        assert.equal(rules.iid, undefined);
+        const DtoCategoryChain = $Dto.get('test-vona:categoryChain', { columns: ['id', 'name', 'categoryIdParent'] });
+        const _apiJson = await app.bean.scope('a-openapi').service.openapi.generateJsonOfClass(DtoCategoryChain);
+        // console.log(JSON.stringify(apiJson.components));
+      });
+    });
+  });
+});

package/test/database/dtoGroup.test.ts

@@ -0,0 +1,44 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+import { getTargetDecoratorRules } from 'vona-module-a-openapi';
+import { $Dto } from 'vona-module-a-orm';
+import { ModelUserStatsGroup } from 'vona-module-test-vona';
+
+describe('dtoGroup.test.ts', () => {
+  it('action:dtoGroup', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.executor.mockCtx(async () => {
+        const DtoUserAggr = $Dto.group('test-vona:user', ['name'], {
+          count: ['*', 'age'],
+          sum: ['age'],
+          avg: 'age',
+          // max: 'age',
+          // min: 'age',
+        });
+        let rules: any;
+        rules = getTargetDecoratorRules(DtoUserAggr.prototype);
+        assert.equal(rules.name._def.typeName, 'ZodString');
+        assert.equal(rules.count_all._def.typeName, 'ZodOptional');
+        assert.equal(rules.count_all._def.innerType._def.typeName, 'ZodUnion');
+        assert.equal(rules.count_all._def.innerType._def.options[0]._def.typeName, 'ZodString');
+        assert.equal(rules.count_all._def.innerType._def.options[1]._def.typeName, 'ZodNumber');
+        assert.equal(rules.count_age._def.typeName, 'ZodOptional');
+        assert.equal(rules.sum_age._def.typeName, 'ZodOptional');
+        assert.equal(rules.avg_age._def.typeName, 'ZodOptional');
+        assert.equal(rules.max_age, undefined);
+        assert.equal(rules.min_age, undefined);
+        // group: userStats: posts: autoload
+        const DtoUserStats = $Dto.get(() => ModelUserStatsGroup, {
+          columns: 'name',
+          include: { roles: true },
+        });
+        rules = getTargetDecoratorRules(DtoUserStats.prototype);
+        assert.equal(rules.name._def.typeName, 'ZodString');
+        assert.equal(rules.iid, undefined);
+        assert.equal(rules.posts._def.typeName, 'ZodEffects');
+        assert.equal(rules.roles._def.typeName, 'ZodEffects');
+      });
+    });
+  });
+});

package/test/database/dtoLazy.test.ts

@@ -0,0 +1,45 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { OpenApiGeneratorV31, OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import { appResource, cast } from 'vona';
+import { app } from 'vona-mock';
+import { $schema } from 'vona-module-a-openapi';
+import { DtoUserLazy } from 'vona-module-test-vona';
+
+describe('dtoLazy.test.ts', () => {
+  it('action:dtoLazy', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const data = {
+        name: 'kevin',
+        other: 'other',
+        user: {
+          id: 1,
+          name: 'tom',
+          married: 1,
+        },
+        roles: [{ id: 2, name: 'admin' }],
+      };
+      const schema = $schema(DtoUserLazy);
+      const res = await schema.parseAsync(data);
+      assert.equal(res.name, 'kevin');
+      assert.equal(cast(res).other, undefined);
+      assert.equal(res.user?.name, 'tom');
+      assert.equal(cast(res.user)?.married, undefined);
+      assert.equal(res.roles?.length, 1);
+      assert.equal(res.roles?.[0].name, 'admin');
+      assert.equal(cast(res.roles?.[0])?.id, undefined);
+    });
+  });
+  it('action:openapi', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const registry = new OpenAPIRegistry();
+      const beanOptions = appResource.getBean(DtoUserLazy)!;
+      const schema = $schema(beanOptions.beanClass);
+      registry.register(beanOptions.beanFullName, schema);
+      const generator = new OpenApiGeneratorV31(registry.definitions);
+      const apiObj = generator.generateDocument(app.bean.scope('a-openapi').config.generateDocument.V31);
+      assert.equal(cast(apiObj).components.schemas['test-vona.dto.userLazy'].properties.user.$ref, '#/components/schemas/test-vona.dto.userLazy');
+      assert.equal(cast(apiObj).components.schemas['test-vona.dto.roleLazy'].properties.users.items.$ref, '#/components/schemas/test-vona.dto.userLazy');
+    });
+  });
+});

package/test/database/dtoMutate.test.ts

@@ -0,0 +1,56 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+import { getTargetDecoratorRules } from 'vona-module-a-openapi';
+import { $Dto, $relationDynamic } from 'vona-module-a-orm';
+import { ModelPost } from 'vona-module-test-vona';
+
+describe('dtoMutate.test.ts', () => {
+  it('action:dtoMutate', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.executor.mockCtx(async () => {
+        // create
+        const DtoUserCreate = $Dto.create('test-vona:user', {
+          include: { posts: true },
+        });
+        let rules: any;
+        rules = getTargetDecoratorRules(DtoUserCreate.prototype);
+        assert.equal(rules.name._def.typeName, 'ZodString');
+        assert.equal(rules.id, undefined);
+        assert.equal(rules.iid, undefined);
+        assert.equal(rules.deleted, undefined);
+        assert.equal(rules.createdAt, undefined);
+        assert.equal(rules.updatedAt, undefined);
+        assert.equal(rules.posts._def.typeName, 'ZodOptional');
+        // update
+        const DtoUserUpdate = $Dto.update('test-vona:user', {
+          with: {
+            posts: $relationDynamic.hasMany(() => ModelPost, 'userId', { columns: ['id', 'title'] }),
+          },
+        });
+        rules = getTargetDecoratorRules(DtoUserUpdate.prototype);
+        assert.equal(rules.name._def.typeName, 'ZodString'); // ZodOptional
+        assert.equal(rules.id, undefined);
+        assert.equal(rules.iid, undefined);
+        assert.equal(rules.deleted, undefined);
+        assert.equal(rules.createdAt, undefined);
+        assert.equal(rules.updatedAt, undefined);
+        assert.equal(rules.posts._def.typeName, 'ZodOptional');
+        // create: not mutate post(belongsTo)
+        const DtoPostCreate = $Dto.create('test-vona:post', {
+          include: {
+            postContent: true,
+            user: true,
+          },
+        });
+        rules = getTargetDecoratorRules(DtoPostCreate.prototype);
+        assert.equal(rules.title._def.typeName, 'ZodString'); // ZodOptional
+        assert.equal(rules.stars._def.typeName, 'ZodOptional');
+        assert.equal(['ZodString', 'ZodNumber'].includes(rules.userId._def.typeName), true);
+        assert.equal(rules.postContent._def.typeName, 'ZodOptional');
+        assert.equal(rules.user, undefined);
+        assert.equal(rules.id, undefined);
+      });
+    });
+  });
+});

package/test/database/modelAggregate.test.ts

@@ -0,0 +1,197 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { cast } from 'vona';
+import { app } from 'vona-mock';
+import { $relationDynamic } from 'vona-module-a-orm';
+import { ModelPost, ModelRole, ModelRoleUser } from 'vona-module-test-vona';
+
+describe('modelAggregate.test.ts', () => {
+  it('action:modelAggregate', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const prefix = 'action:modelAggregate';
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      // insert: roles
+      const roles = await scopeTest.model.role.insertBulk([
+        { name: `${prefix}:family` },
+        { name: `${prefix}:friend` },
+      ]);
+      assert.equal(roles.length, 2);
+      assert.equal(roles[0].id !== undefined, true);
+      // create: users
+      const users = await scopeTest.model.user.insertBulk([
+        {
+          name: `${prefix}:tom`,
+          age: 3,
+          posts: [
+            {
+              title: `${prefix}:postApple`,
+              stars: 2,
+              postContent: {
+                content: `${prefix}:postContentApple`,
+              },
+            },
+            {
+              title: `${prefix}:postApple2`,
+              stars: 3,
+              postContent: {
+                content: `${prefix}:postContentApple2`,
+              },
+            },
+          ],
+          roles: [{
+            id: roles[0].id,
+          }],
+        },
+        {
+          name: `${prefix}:jimmy`,
+          age: 5,
+          posts: [{
+            title: `${prefix}:postPear`,
+            stars: 4,
+            postContent: {
+              content: `${prefix}:postContentPear`,
+            },
+          }],
+        },
+        { name: `${prefix}:mike` },
+      ], {
+        include: {
+          posts: { include: { postContent: true } },
+          roles: true,
+        },
+      });
+      // count: user
+      const userCount = await scopeTest.model.user.count({
+        column: '*',
+        where: {
+          name: { _startsWith_: `${prefix}:` },
+        },
+      });
+      assert.equal(userCount, 3);
+      // aggr: user
+      const userStats = await scopeTest.model.user.aggregate({
+        aggrs: {
+          count: ['*', 'age'],
+          sum: ['age'],
+          avg: 'age',
+          max: 'age',
+        },
+        where: {
+          name: { _startsWith_: `${prefix}:` },
+        },
+      });
+      assert.equal(userStats.count_all, 3);
+      assert.equal(userStats.count_age, 2);
+      assert.equal(userStats.sum_age, 8);
+      assert.equal(userStats.avg_age, 4);
+      assert.equal(userStats.max_age, 5);
+      // aggr: usersStats: posts: autoload
+      const usersStats = await scopeTest.model.userStats.select({
+        where: {
+          id: users.map(item => item.id),
+        },
+        orders: [['id', 'asc']],
+        include: {
+          roles: true,
+        },
+      });
+      assert.equal(usersStats.length, 3);
+      assert.equal(usersStats[0].posts?.count_all, 2);
+      assert.equal(usersStats[0].posts?.count_title, 2);
+      assert.equal(usersStats[0].posts?.sum_stars, 5);
+      assert.equal(usersStats[0].roles?.count_all, 1);
+      // aggr: usersStats: posts: mixed
+      const usersStats2 = await scopeTest.model.userStats.select({
+        where: {
+          id: users.map(item => item.id),
+        },
+        orders: [['id', 'asc']],
+        include: {
+          posts: { aggrs: { count: '*' } },
+          roles: true,
+        },
+      });
+      assert.equal(usersStats2.length, 3);
+      assert.equal(usersStats2[0].posts?.count_all, 2);
+      assert.equal(cast(usersStats2[0].posts).count_title, undefined);
+      assert.equal(usersStats2[0].posts?.sum_stars, 5);
+      assert.equal(usersStats2[0].roles?.count_all, 1);
+      // aggr: usersStats: posts: disable
+      const usersStats3 = await scopeTest.model.userStats.select({
+        where: {
+          id: users.map(item => item.id),
+        },
+        orders: [['id', 'asc']],
+        include: {
+          posts: {
+            aggrs: {
+              count: ['*'],
+              sum: [],
+            },
+          },
+          roles: true,
+        },
+      });
+      assert.equal(usersStats3.length, 3);
+      assert.equal(usersStats3[0].posts?.count_all, 2);
+      assert.equal(cast(usersStats3[0].posts).count_title, undefined);
+      assert.equal(cast(usersStats3[0].posts).sum_stars, undefined);
+      assert.equal(usersStats3[0].roles?.count_all, 1);
+      // aggr: usersStats: with
+      const usersStats4 = await scopeTest.model.userStats.select({
+        where: {
+          id: users.map(item => item.id),
+        },
+        orders: [['id', 'asc']],
+        include: {
+          posts: false,
+          roles: false,
+        },
+        with: {
+          posts: $relationDynamic.hasMany(() => ModelPost, 'userId', {
+            aggrs: { count: '*' },
+          }),
+          roles: $relationDynamic.belongsToMany(() => ModelRoleUser, () => ModelRole, 'userId', 'roleId', {
+            aggrs: { count: '*' },
+          }),
+        },
+      });
+      assert.equal(usersStats4.length, 3);
+      assert.equal(usersStats4[0].posts?.count_all, 2);
+      assert.equal(cast(usersStats4[0].posts).count_title, undefined);
+      assert.equal(cast(usersStats4[0].posts).sum_stars, undefined);
+      assert.equal(usersStats4[0].roles?.count_all, 1);
+      // aggr: get
+      const userStats4 = await scopeTest.model.userStats.get({
+        id: users[0].id,
+      }, {
+        include: {
+          posts: false,
+          roles: false,
+        },
+        with: {
+          posts: $relationDynamic.hasMany(() => ModelPost, 'userId', {
+            aggrs: { count: '*' },
+          }),
+          roles: $relationDynamic.belongsToMany(() => ModelRoleUser, () => ModelRole, 'userId', 'roleId', {
+            aggrs: { count: '*' },
+          }),
+        },
+      });
+      assert.equal(userStats4?.posts?.count_all, 2);
+      assert.equal(cast(userStats4?.posts).count_title, undefined);
+      assert.equal(cast(userStats4?.posts).sum_stars, undefined);
+      assert.equal(userStats4?.roles?.count_all, 1);
+      // delete: users
+      await scopeTest.model.user.deleteBulk(users.map(item => item.id), {
+        include: {
+          posts: { include: { postContent: true } },
+          roles: true,
+        },
+      });
+      // delete: roles
+      await scopeTest.model.role.deleteBulk(roles.map(item => item.id));
+    });
+  });
+});