vona-module-test-vona 5.0.38 → 5.0.41

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));
+    });
+  });
+});

package/test/database/modelCache.test.ts

@@ -0,0 +1,37 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('modelCache.test.ts', () => {
+  it('action:modelCache:cacheQuery', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const prefix = 'action:modelCache:cacheQuery';
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      // create
+      const user = await scopeTest.model.user.insert({ name: `${prefix}:1` });
+      // select
+      let items = await scopeTest.model.user.select({ where: { name: `${prefix}:1` } });
+      assert.equal(items.length, 1);
+      // select again
+      items = await scopeTest.model.user.select({ where: { name: `${prefix}:1` } });
+      assert.equal(items.length, 1);
+      // get
+      const user2 = await scopeTest.model.user.get({ id: user.id });
+      const user3 = await scopeTest.model.user.get({ name: `${prefix}:1` });
+      const user4 = await scopeTest.model.user.get({ name: `${prefix}:1` });
+      assert.equal(user2?.id, user3?.id);
+      assert.equal(user3?.id, user4?.id);
+      // update
+      await scopeTest.model.user.update({ id: user.id, name: `${prefix}:2` });
+      // select
+      items = await scopeTest.model.user.select({ where: { name: `${prefix}:2` } });
+      assert.equal(items.length, 1);
+      // delete
+      await scopeTest.model.user.delete({ name: `${prefix}:2` });
+      // select
+      items = await scopeTest.model.user.select({ where: { name: `${prefix}:2` } });
+      assert.equal(items.length, 0);
+    });
+  });
+});

package/test/database/modelGeneral.test.ts

@@ -0,0 +1,18 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { isNil } from '@cabloy/utils';
+import { app } from 'vona-mock';
+
+describe('model.test.ts', () => {
+  it('action:model:defaultValue', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      // create
+      const item = await scopeTest.model.test.insert();
+      assert.equal(isNil(item.testDate), false);
+      // delete
+      await scopeTest.model.test.delete({ id: item.id });
+    });
+  });
+});