vona-module-test-vona 5.0.39 → 5.0.42

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

package/test/database/modelGroup.test.ts

@@ -0,0 +1,211 @@
+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('modelGroup.test.ts', () => {
+  it('action:modelGroup', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const prefix = 'action:modelGroup';
+      // 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,
+        },
+      });
+      // group: user
+      const usersGroup = await scopeTest.model.user.group({
+        groups: ['name'],
+        aggrs: {
+          count: ['*', 'age'],
+          sum: ['age'],
+          avg: 'age',
+          max: 'age',
+        },
+        where: {
+          name: { _startsWith_: `${prefix}:` },
+        },
+        having: {
+          _and_: {
+            name: { _startsWith_: `${prefix}:` },
+            max_age: { _isNot_: null },
+          },
+          count_all: { _gt_: 0 },
+        },
+        orders: [['max_age', 'desc']],
+      });
+      assert.equal(usersGroup.length, 2);
+      assert.equal(usersGroup[0].name, `${prefix}:jimmy`);
+      assert.equal(usersGroup[0].count_all, 1);
+      assert.equal(usersGroup[0].count_age, 1);
+      assert.equal(usersGroup[0].sum_age, 5);
+      assert.equal(usersGroup[0].avg_age, 5);
+      assert.equal(usersGroup[0].max_age, 5);
+      // group: usersStats: posts: autoload
+      const usersStats = await scopeTest.model.userStatsGroup.select({
+        where: {
+          id: users.map(item => item.id),
+        },
+        orders: [['id', 'asc']],
+        include: {
+          roles: true,
+        },
+      });
+      assert.equal(usersStats.length, 3);
+      assert.equal(usersStats[0].posts[0].title, `${prefix}:postApple2`);
+      assert.equal(usersStats[0].posts[0].count_all, 1);
+      assert.equal(usersStats[0].posts[0].count_title, 1);
+      assert.equal(usersStats[0].posts[0].sum_stars, 3);
+      assert.equal(usersStats[0].roles[0].count_all, 1);
+      // group: usersStats: posts: mixed
+      const usersStats2 = await scopeTest.model.userStatsGroup.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[0].title, `${prefix}:postApple2`);
+      assert.equal(usersStats2[0].posts[0].count_all, 1);
+      assert.equal(cast(usersStats2[0].posts[0]).count_title, undefined);
+      assert.equal(usersStats2[0].posts[0].sum_stars, 3);
+      assert.equal(usersStats2[0].roles[0].count_all, 1);
+      // group: usersStats: posts: disable
+      const usersStats3 = await scopeTest.model.userStatsGroup.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[0].title, `${prefix}:postApple2`);
+      assert.equal(usersStats3[0].posts[0].count_all, 1);
+      assert.equal(cast(usersStats3[0].posts[0]).count_title, undefined);
+      assert.equal(cast(usersStats3[0].posts[0]).sum_stars, undefined);
+      assert.equal(usersStats3[0].roles[0].count_all, 1);
+      // group: usersStats: with
+      const usersStats4 = await scopeTest.model.userStatsGroup.select({
+        where: {
+          id: users.map(item => item.id),
+        },
+        orders: [['id', 'asc']],
+        include: {
+          posts: false,
+          roles: false,
+        },
+        with: {
+          posts: $relationDynamic.hasMany(() => ModelPost, 'userId', {
+            groups: ['title'],
+            aggrs: { count: '*' },
+            orders: [['title', 'desc']],
+          }, undefined, true),
+          roles: $relationDynamic.belongsToMany(() => ModelRoleUser, () => ModelRole, 'userId', 'roleId', {
+            groups: 'name',
+            aggrs: { count: '*' },
+          }),
+        },
+      });
+      assert.equal(usersStats4.length, 3);
+      assert.equal(usersStats4[0].posts[0].title, `${prefix}:postApple2`);
+      assert.equal(usersStats4[0].posts[0].count_all, 1);
+      assert.equal(cast(usersStats4[0].posts[0]).count_title, undefined);
+      assert.equal(cast(usersStats4[0].posts[0]).sum_stars, undefined);
+      assert.equal(usersStats4[0].roles[0].count_all, 1);
+      // group: get
+      const userStats4 = await scopeTest.model.userStatsGroup.get({
+        id: users[0].id,
+      }, {
+        include: {
+          posts: false,
+          roles: false,
+        },
+        with: {
+          posts: $relationDynamic.hasMany(() => ModelPost, 'userId', {
+            groups: ['title'],
+            aggrs: { count: '*' },
+            orders: [['title', 'desc']],
+          }, undefined, true),
+          roles: $relationDynamic.belongsToMany(() => ModelRoleUser, () => ModelRole, 'userId', 'roleId', {
+            groups: 'name',
+            aggrs: { count: '*' },
+          }),
+        },
+      });
+      assert.equal(userStats4?.posts[0].title, `${prefix}:postApple2`);
+      assert.equal(userStats4?.posts[0].count_all, 1);
+      assert.equal(cast(userStats4?.posts[0]).count_title, undefined);
+      assert.equal(cast(userStats4?.posts[0]).sum_stars, undefined);
+      assert.equal(userStats4?.roles[0].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/modelRelations.test.ts

@@ -0,0 +1,203 @@
+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, ModelPostContent, ModelUser } from 'vona-module-test-vona';
+
+describe('modelRelations.test.ts', () => {
+  it('action:modelRelations', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const prefix = 'action:modelRelations';
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      // test data: create
+      const testData = await scopeTest.service.testData.create(prefix);
+      const {
+        userTom,
+        userJimmy,
+        roleFamily,
+        roleFriend,
+        postApple,
+        postPear,
+        postContentApple,
+      } = testData;
+      // relation: hasOne
+      const posts = await scopeTest.model.post.select({
+        columns: ['id', 'title', 'userId'],
+        where: {
+          id: [postApple.id, postPear.id],
+        },
+        orders: [['id', 'asc']],
+        include: { postContent: true },
+      });
+      assert.equal(posts.length, 2);
+      assert.equal(posts[0].postContent?.content, 'action:modelRelations:postContentApple');
+      assert.equal(cast(posts[0].postContent)?.iid, undefined);
+      assert.equal(posts[1].postContent, undefined);
+      // relation: hasOne: get
+      const postGet = await scopeTest.model.post.get(
+        { id: postApple.id },
+        { columns: 'id', include: { postContent: true } },
+      );
+      assert.equal(cast(postGet)?.iid, undefined);
+      assert.equal(postGet?.postContent?.content, 'action:modelRelations:postContentApple');
+      // relation: hasOne: columns
+      const postGetColumns = await scopeTest.model.post.get(
+        { id: postApple.id },
+        { columns: ['id'], include: { postContent: { columns: ['id'] } } },
+      );
+      assert.equal(cast(postGetColumns?.postContent)?.content, undefined);
+      assert.equal(Object.keys(postGetColumns!.postContent!).length, 1);
+      assert.equal(Object.keys(postGetColumns!).length, 1 + 2);// .user + .postContent
+      // relation: belongsTo
+      const postContents = await scopeTest.model.postContent.select({
+        where: {
+          id: postContentApple.id,
+        },
+        include: { post: true },
+      });
+      assert.equal(postContents.length, 1);
+      assert.equal(postContents[0].post?.title, 'action:modelRelations:postApple');
+      // relation: belongsTo: get
+      const postContentGet = await scopeTest.model.postContent.get(
+        { id: postContentApple.id },
+        { include: { post: true } },
+      );
+      assert.equal(postContentGet?.post?.title, 'action:modelRelations:postApple');
+      // relation: belongsTo: autoload
+      const postAutoload = await scopeTest.model.post.get(
+        { id: postApple.id },
+      );
+      assert.equal(postAutoload!.user?.id, postAutoload!.userId);
+      assert.equal(cast(postAutoload?.user)?.iid, undefined);
+      assert.equal(Object.keys(postAutoload!.user!).length, 2); // id + name
+      // relation: hasMany
+      const users = await scopeTest.model.user.select({
+        where: {
+          id: [userTom.id, userJimmy.id],
+        },
+        orders: [['id', 'asc']],
+        include: { posts: true },
+      });
+      assert.equal(users.length, 2);
+      assert.equal(users[0].posts.length, 2);
+      assert.equal(users[1].posts.length, 0);
+      // relation: hasMany: options.where/orders
+      const userOptions = await scopeTest.model.user.select({
+        where: {
+          id: [userTom.id, userJimmy.id],
+        },
+        orders: [['id', 'asc']],
+        include: { posts: {
+          where: {
+            id: { _in_: [postApple.id, postPear.id] },
+          },
+          orders: [['id', 'desc']],
+        } },
+      });
+      assert.equal(userOptions.length, 2);
+      assert.equal(userOptions[0].posts.length, 2);
+      assert.equal(userOptions[1].posts.length, 0);
+      assert.equal(cast(userOptions[0].posts[0]).iid, undefined);
+      assert.equal(Number.parseInt(userOptions[0].posts[0].id as any) > Number.parseInt(userOptions[0].posts[1].id as any), true);
+      // relation: hasMany: options.where/orders
+      const userOptions2 = await scopeTest.model.user.select({
+        where: {
+          id: [userTom.id, userJimmy.id],
+        },
+        orders: [['id', 'asc']],
+        include: {
+          posts: {
+            joins: [['innerJoin', 'testVonaPostContent', ['testVonaPost.id', 'testVonaPostContent.postId']]],
+            where: {
+              'testVonaPost.id': { _in_: [postApple.id, postPear.id] },
+              '_and_': { 'testVonaPost.id': { _notIn_: [postApple.id, postPear.id] } },
+              'testVonaPostContent.id': [postContentApple.id],
+            },
+            orders: [['testVonaPost.id', 'desc']],
+          },
+          roles: true,
+        },
+      });
+      assert.equal(userOptions2.length, 2);
+      assert.equal(userOptions2[0].posts.length, 0);
+      assert.equal(userOptions2[1].posts.length, 0);
+      // relation: hasMany: get
+      const userGet = await scopeTest.model.user.get(
+        { id: userTom.id },
+        { include: { posts: true } },
+      );
+      assert.equal(userGet?.posts.length, 2);
+      // relation: belongsToMany
+      const roles = await scopeTest.model.role.select({
+        where: {
+          id: [roleFamily.id, roleFriend.id],
+        },
+        orders: [['id', 'asc']],
+        include: { users: true },
+      });
+      assert.equal(roles.length, 2);
+      assert.equal(roles[0].users.length, 2);
+      assert.equal(roles[1].users.length, 1);
+      // relation: belongsToMany: get
+      const roleGet = await scopeTest.model.role.get(
+        { id: roleFamily.id },
+        { include: { users: true } },
+      );
+      assert.equal(roleGet?.users.length, 2);
+      assert.equal(cast(roleGet?.users[0]).iid, undefined);
+      // relation: belongsToMany: mget
+      const roles2 = await scopeTest.model.role.mget([roleFamily.id, roleFriend.id], { columns: ['id', 'name'], include: { users: true } });
+      assert.equal(roles2.length, 2);
+      assert.equal(cast(roles2[0]).iid, undefined);
+      assert.equal(roles2[0].users.length, 2);
+      assert.equal(roles2[1].users.length, 1);
+      // relation: include + with
+      const items = await scopeTest.model.post.select(
+        {
+          where: {
+            id: postApple.id,
+          },
+          include: {
+            postContent: {
+              include: {
+                post: { include: { user: { columns: ['id'] } }, meta: { client: '_auto_' } },
+              },
+              with: {
+                post3: $relationDynamic.belongsTo(() => ModelPostContent, () => ModelPost, 'postId', {
+                  include: {
+                    postContent: true,
+                  },
+                }),
+              },
+            },
+          },
+          with: {
+            user3: $relationDynamic.belongsTo(ModelPost, () => ModelUser, 'userId', {
+              include: { posts: true },
+              with: {
+                roles: $relationDynamic.belongsToMany(
+                  'test-vona:roleUser',
+                  'test-vona:role',
+                  'userId',
+                  'roleId',
+                  { columns: ['id', 'name'], meta: { client: '_auto_' } },
+                ),
+              },
+              columns: ['id', 'name'],
+            }),
+          },
+        },
+      );
+      assert.equal(Object.keys(items[0].postContent!.post!.user!).length, 1);
+      assert.equal(items[0].postContent?.post3?.postContent?.content !== undefined, true);
+      assert.equal(items[0].user3!.posts.length > 0, true);
+      assert.equal(items[0].user3!.roles.length > 0, true);
+      assert.equal(cast(items[0].user3!.roles[0]).iid, undefined);
+      assert.equal(cast(items[0].user3)?.iid, undefined);
+      // test data: delete
+      await scopeTest.service.testData.drop(testData);
+    });
+  });
+});

package/test/database/modelRelationsJoins.test.ts

@@ -0,0 +1,39 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('modelRelationsJoins.test.ts', () => {
+  it('action:modelRelationsJoins', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const prefix = 'action:modelRelationsJoins';
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      // test data: create
+      const testData = await scopeTest.service.testData.create(prefix);
+      const {
+        userTom,
+        userJimmy,
+      } = testData;
+      // joins: auto
+      const itemsJoins = await scopeTest.model.post.select({
+        joins: [['innerJoin', 'testVonaUser', ['testVonaPost.userId', 'testVonaUser.id']]],
+        where: {
+          'testVonaUser.id': userTom.id,
+        },
+        orders: [['testVonaUser.id', 'asc']],
+      });
+      assert.equal(itemsJoins.length, 2);
+      // joins: manual
+      const itemsJoins2 = await scopeTest.model.post.select({
+        joins: [['innerJoin', 'testVonaUser', ['testVonaPost.userId', 'testVonaUser.id']]],
+        where: {
+          'testVonaUser.id': userJimmy.id,
+        },
+        orders: [['testVonaUser.id', 'asc']],
+      }, {}, ['test-vona:user']);
+      assert.equal(itemsJoins2.length, 0);
+      // test data: delete
+      await scopeTest.service.testData.drop(testData);
+    });
+  });
+});